1 /** 2 * Autogenerated by Thrift for src/module.thrift 3 * 4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING 5 * @generated @nocommit 6 */ 7 #pragma once 8 9 #include <thrift/lib/cpp2/gen/client_h.h> 10 11 #include "thrift/compiler/test/fixtures/visitation/gen-cpp2/module_types.h" 12 #include "thrift/compiler/test/fixtures/visitation/gen-cpp2/reflection_dep_B_types.h" 13 #include "thrift/compiler/test/fixtures/visitation/gen-cpp2/reflection_dep_C_types.h" 14 #include "thrift/test/fatal_custom_types.h" 15 16 namespace apache { namespace thrift { 17 class Cpp2RequestContext; 18 namespace detail { namespace ac { struct ClientRequestContext; }} 19 namespace transport { class THeader; } 20 }} 21 22 namespace test_cpp2 { namespace cpp_reflection { 23 24 class service_with_special_namesAsyncClient : public apache::thrift::GeneratedAsyncClient { 25 public: 26 using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; 27 getServiceName()28 char const* getServiceName() const noexcept override { 29 return "service_with_special_names"; 30 } 31 32 33 virtual void get(std::unique_ptr<apache::thrift::RequestCallback> callback); 34 virtual void get(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 35 protected: 36 void getImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 37 public: 38 39 virtual ::std::int32_t sync_get(); 40 virtual ::std::int32_t sync_get(apache::thrift::RpcOptions& rpcOptions); 41 42 virtual folly::Future<::std::int32_t> future_get(); 43 virtual folly::SemiFuture<::std::int32_t> semifuture_get(); 44 virtual folly::Future<::std::int32_t> future_get(apache::thrift::RpcOptions& rpcOptions); 45 virtual folly::SemiFuture<::std::int32_t> semifuture_get(apache::thrift::RpcOptions& rpcOptions); 46 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_get(apache::thrift::RpcOptions& rpcOptions); 47 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_get(apache::thrift::RpcOptions& rpcOptions); 48 49 #if FOLLY_HAS_COROUTINES 50 template <int = 0> co_get()51 folly::coro::Task<::std::int32_t> co_get() { 52 return co_get<false>(nullptr); 53 } 54 template <int = 0> co_get(apache::thrift::RpcOptions & rpcOptions)55 folly::coro::Task<::std::int32_t> co_get(apache::thrift::RpcOptions& rpcOptions) { 56 return co_get<true>(&rpcOptions); 57 } 58 private: 59 template <bool hasRpcOptions> co_get(apache::thrift::RpcOptions * rpcOptions)60 folly::coro::Task<::std::int32_t> co_get(apache::thrift::RpcOptions* rpcOptions) { 61 const folly::CancellationToken& cancelToken = 62 co_await folly::coro::co_current_cancellation_token; 63 const bool cancellable = cancelToken.canBeCancelled(); 64 apache::thrift::ClientReceiveState returnState; 65 apache::thrift::ClientSyncCallback<false> callback(&returnState); 66 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 67 auto [ctx, header] = getCtx(rpcOptions); 68 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 69 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 70 static apache::thrift::RpcOptions defaultRpcOptions; 71 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 72 if constexpr (hasRpcOptions) { 73 getImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 74 } else { 75 getImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 76 } 77 if (cancellable) { 78 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 79 co_await callback.co_waitUntilDone(); 80 } else { 81 co_await callback.co_waitUntilDone(); 82 } 83 if (returnState.isException()) { 84 co_yield folly::coro::co_error(std::move(returnState.exception())); 85 } 86 returnState.resetProtocolId(protocolId); 87 returnState.resetCtx(std::move(ctx)); 88 SCOPE_EXIT { 89 if (hasRpcOptions && returnState.header()) { 90 auto* rheader = returnState.header(); 91 if (!rheader->getHeaders().empty()) { 92 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 93 } 94 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 95 } 96 }; 97 ::std::int32_t _return; 98 if (auto ew = recv_wrapped_get(_return, returnState)) { 99 co_yield folly::coro::co_error(std::move(ew)); 100 } 101 co_return _return; 102 } 103 public: 104 #endif // FOLLY_HAS_COROUTINES 105 106 virtual void get(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 107 108 109 static folly::exception_wrapper recv_wrapped_get(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 110 static ::std::int32_t recv_get(::apache::thrift::ClientReceiveState& state); 111 // Mock friendly virtual instance method 112 virtual ::std::int32_t recv_instance_get(::apache::thrift::ClientReceiveState& state); 113 virtual folly::exception_wrapper recv_instance_wrapped_get(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 114 private: 115 template <typename Protocol_, typename RpcOptions> 116 void getT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 117 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> getCtx(apache::thrift::RpcOptions* rpcOptions); 118 public: 119 virtual void getter(std::unique_ptr<apache::thrift::RequestCallback> callback); 120 virtual void getter(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 121 protected: 122 void getterImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 123 public: 124 125 virtual ::std::int32_t sync_getter(); 126 virtual ::std::int32_t sync_getter(apache::thrift::RpcOptions& rpcOptions); 127 128 virtual folly::Future<::std::int32_t> future_getter(); 129 virtual folly::SemiFuture<::std::int32_t> semifuture_getter(); 130 virtual folly::Future<::std::int32_t> future_getter(apache::thrift::RpcOptions& rpcOptions); 131 virtual folly::SemiFuture<::std::int32_t> semifuture_getter(apache::thrift::RpcOptions& rpcOptions); 132 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_getter(apache::thrift::RpcOptions& rpcOptions); 133 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_getter(apache::thrift::RpcOptions& rpcOptions); 134 135 #if FOLLY_HAS_COROUTINES 136 template <int = 0> co_getter()137 folly::coro::Task<::std::int32_t> co_getter() { 138 return co_getter<false>(nullptr); 139 } 140 template <int = 0> co_getter(apache::thrift::RpcOptions & rpcOptions)141 folly::coro::Task<::std::int32_t> co_getter(apache::thrift::RpcOptions& rpcOptions) { 142 return co_getter<true>(&rpcOptions); 143 } 144 private: 145 template <bool hasRpcOptions> co_getter(apache::thrift::RpcOptions * rpcOptions)146 folly::coro::Task<::std::int32_t> co_getter(apache::thrift::RpcOptions* rpcOptions) { 147 const folly::CancellationToken& cancelToken = 148 co_await folly::coro::co_current_cancellation_token; 149 const bool cancellable = cancelToken.canBeCancelled(); 150 apache::thrift::ClientReceiveState returnState; 151 apache::thrift::ClientSyncCallback<false> callback(&returnState); 152 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 153 auto [ctx, header] = getterCtx(rpcOptions); 154 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 155 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 156 static apache::thrift::RpcOptions defaultRpcOptions; 157 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 158 if constexpr (hasRpcOptions) { 159 getterImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 160 } else { 161 getterImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 162 } 163 if (cancellable) { 164 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 165 co_await callback.co_waitUntilDone(); 166 } else { 167 co_await callback.co_waitUntilDone(); 168 } 169 if (returnState.isException()) { 170 co_yield folly::coro::co_error(std::move(returnState.exception())); 171 } 172 returnState.resetProtocolId(protocolId); 173 returnState.resetCtx(std::move(ctx)); 174 SCOPE_EXIT { 175 if (hasRpcOptions && returnState.header()) { 176 auto* rheader = returnState.header(); 177 if (!rheader->getHeaders().empty()) { 178 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 179 } 180 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 181 } 182 }; 183 ::std::int32_t _return; 184 if (auto ew = recv_wrapped_getter(_return, returnState)) { 185 co_yield folly::coro::co_error(std::move(ew)); 186 } 187 co_return _return; 188 } 189 public: 190 #endif // FOLLY_HAS_COROUTINES 191 192 virtual void getter(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 193 194 195 static folly::exception_wrapper recv_wrapped_getter(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 196 static ::std::int32_t recv_getter(::apache::thrift::ClientReceiveState& state); 197 // Mock friendly virtual instance method 198 virtual ::std::int32_t recv_instance_getter(::apache::thrift::ClientReceiveState& state); 199 virtual folly::exception_wrapper recv_instance_wrapped_getter(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 200 private: 201 template <typename Protocol_, typename RpcOptions> 202 void getterT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 203 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> getterCtx(apache::thrift::RpcOptions* rpcOptions); 204 public: 205 virtual void lists(std::unique_ptr<apache::thrift::RequestCallback> callback); 206 virtual void lists(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 207 protected: 208 void listsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 209 public: 210 211 virtual ::std::int32_t sync_lists(); 212 virtual ::std::int32_t sync_lists(apache::thrift::RpcOptions& rpcOptions); 213 214 virtual folly::Future<::std::int32_t> future_lists(); 215 virtual folly::SemiFuture<::std::int32_t> semifuture_lists(); 216 virtual folly::Future<::std::int32_t> future_lists(apache::thrift::RpcOptions& rpcOptions); 217 virtual folly::SemiFuture<::std::int32_t> semifuture_lists(apache::thrift::RpcOptions& rpcOptions); 218 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_lists(apache::thrift::RpcOptions& rpcOptions); 219 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_lists(apache::thrift::RpcOptions& rpcOptions); 220 221 #if FOLLY_HAS_COROUTINES 222 template <int = 0> co_lists()223 folly::coro::Task<::std::int32_t> co_lists() { 224 return co_lists<false>(nullptr); 225 } 226 template <int = 0> co_lists(apache::thrift::RpcOptions & rpcOptions)227 folly::coro::Task<::std::int32_t> co_lists(apache::thrift::RpcOptions& rpcOptions) { 228 return co_lists<true>(&rpcOptions); 229 } 230 private: 231 template <bool hasRpcOptions> co_lists(apache::thrift::RpcOptions * rpcOptions)232 folly::coro::Task<::std::int32_t> co_lists(apache::thrift::RpcOptions* rpcOptions) { 233 const folly::CancellationToken& cancelToken = 234 co_await folly::coro::co_current_cancellation_token; 235 const bool cancellable = cancelToken.canBeCancelled(); 236 apache::thrift::ClientReceiveState returnState; 237 apache::thrift::ClientSyncCallback<false> callback(&returnState); 238 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 239 auto [ctx, header] = listsCtx(rpcOptions); 240 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 241 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 242 static apache::thrift::RpcOptions defaultRpcOptions; 243 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 244 if constexpr (hasRpcOptions) { 245 listsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 246 } else { 247 listsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 248 } 249 if (cancellable) { 250 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 251 co_await callback.co_waitUntilDone(); 252 } else { 253 co_await callback.co_waitUntilDone(); 254 } 255 if (returnState.isException()) { 256 co_yield folly::coro::co_error(std::move(returnState.exception())); 257 } 258 returnState.resetProtocolId(protocolId); 259 returnState.resetCtx(std::move(ctx)); 260 SCOPE_EXIT { 261 if (hasRpcOptions && returnState.header()) { 262 auto* rheader = returnState.header(); 263 if (!rheader->getHeaders().empty()) { 264 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 265 } 266 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 267 } 268 }; 269 ::std::int32_t _return; 270 if (auto ew = recv_wrapped_lists(_return, returnState)) { 271 co_yield folly::coro::co_error(std::move(ew)); 272 } 273 co_return _return; 274 } 275 public: 276 #endif // FOLLY_HAS_COROUTINES 277 278 virtual void lists(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 279 280 281 static folly::exception_wrapper recv_wrapped_lists(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 282 static ::std::int32_t recv_lists(::apache::thrift::ClientReceiveState& state); 283 // Mock friendly virtual instance method 284 virtual ::std::int32_t recv_instance_lists(::apache::thrift::ClientReceiveState& state); 285 virtual folly::exception_wrapper recv_instance_wrapped_lists(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 286 private: 287 template <typename Protocol_, typename RpcOptions> 288 void listsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 289 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> listsCtx(apache::thrift::RpcOptions* rpcOptions); 290 public: 291 virtual void maps(std::unique_ptr<apache::thrift::RequestCallback> callback); 292 virtual void maps(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 293 protected: 294 void mapsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 295 public: 296 297 virtual ::std::int32_t sync_maps(); 298 virtual ::std::int32_t sync_maps(apache::thrift::RpcOptions& rpcOptions); 299 300 virtual folly::Future<::std::int32_t> future_maps(); 301 virtual folly::SemiFuture<::std::int32_t> semifuture_maps(); 302 virtual folly::Future<::std::int32_t> future_maps(apache::thrift::RpcOptions& rpcOptions); 303 virtual folly::SemiFuture<::std::int32_t> semifuture_maps(apache::thrift::RpcOptions& rpcOptions); 304 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_maps(apache::thrift::RpcOptions& rpcOptions); 305 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_maps(apache::thrift::RpcOptions& rpcOptions); 306 307 #if FOLLY_HAS_COROUTINES 308 template <int = 0> co_maps()309 folly::coro::Task<::std::int32_t> co_maps() { 310 return co_maps<false>(nullptr); 311 } 312 template <int = 0> co_maps(apache::thrift::RpcOptions & rpcOptions)313 folly::coro::Task<::std::int32_t> co_maps(apache::thrift::RpcOptions& rpcOptions) { 314 return co_maps<true>(&rpcOptions); 315 } 316 private: 317 template <bool hasRpcOptions> co_maps(apache::thrift::RpcOptions * rpcOptions)318 folly::coro::Task<::std::int32_t> co_maps(apache::thrift::RpcOptions* rpcOptions) { 319 const folly::CancellationToken& cancelToken = 320 co_await folly::coro::co_current_cancellation_token; 321 const bool cancellable = cancelToken.canBeCancelled(); 322 apache::thrift::ClientReceiveState returnState; 323 apache::thrift::ClientSyncCallback<false> callback(&returnState); 324 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 325 auto [ctx, header] = mapsCtx(rpcOptions); 326 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 327 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 328 static apache::thrift::RpcOptions defaultRpcOptions; 329 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 330 if constexpr (hasRpcOptions) { 331 mapsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 332 } else { 333 mapsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 334 } 335 if (cancellable) { 336 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 337 co_await callback.co_waitUntilDone(); 338 } else { 339 co_await callback.co_waitUntilDone(); 340 } 341 if (returnState.isException()) { 342 co_yield folly::coro::co_error(std::move(returnState.exception())); 343 } 344 returnState.resetProtocolId(protocolId); 345 returnState.resetCtx(std::move(ctx)); 346 SCOPE_EXIT { 347 if (hasRpcOptions && returnState.header()) { 348 auto* rheader = returnState.header(); 349 if (!rheader->getHeaders().empty()) { 350 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 351 } 352 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 353 } 354 }; 355 ::std::int32_t _return; 356 if (auto ew = recv_wrapped_maps(_return, returnState)) { 357 co_yield folly::coro::co_error(std::move(ew)); 358 } 359 co_return _return; 360 } 361 public: 362 #endif // FOLLY_HAS_COROUTINES 363 364 virtual void maps(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 365 366 367 static folly::exception_wrapper recv_wrapped_maps(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 368 static ::std::int32_t recv_maps(::apache::thrift::ClientReceiveState& state); 369 // Mock friendly virtual instance method 370 virtual ::std::int32_t recv_instance_maps(::apache::thrift::ClientReceiveState& state); 371 virtual folly::exception_wrapper recv_instance_wrapped_maps(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 372 private: 373 template <typename Protocol_, typename RpcOptions> 374 void mapsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 375 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> mapsCtx(apache::thrift::RpcOptions* rpcOptions); 376 public: 377 virtual void name(std::unique_ptr<apache::thrift::RequestCallback> callback); 378 virtual void name(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 379 protected: 380 void nameImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 381 public: 382 383 virtual ::std::int32_t sync_name(); 384 virtual ::std::int32_t sync_name(apache::thrift::RpcOptions& rpcOptions); 385 386 virtual folly::Future<::std::int32_t> future_name(); 387 virtual folly::SemiFuture<::std::int32_t> semifuture_name(); 388 virtual folly::Future<::std::int32_t> future_name(apache::thrift::RpcOptions& rpcOptions); 389 virtual folly::SemiFuture<::std::int32_t> semifuture_name(apache::thrift::RpcOptions& rpcOptions); 390 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_name(apache::thrift::RpcOptions& rpcOptions); 391 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_name(apache::thrift::RpcOptions& rpcOptions); 392 393 #if FOLLY_HAS_COROUTINES 394 template <int = 0> co_name()395 folly::coro::Task<::std::int32_t> co_name() { 396 return co_name<false>(nullptr); 397 } 398 template <int = 0> co_name(apache::thrift::RpcOptions & rpcOptions)399 folly::coro::Task<::std::int32_t> co_name(apache::thrift::RpcOptions& rpcOptions) { 400 return co_name<true>(&rpcOptions); 401 } 402 private: 403 template <bool hasRpcOptions> co_name(apache::thrift::RpcOptions * rpcOptions)404 folly::coro::Task<::std::int32_t> co_name(apache::thrift::RpcOptions* rpcOptions) { 405 const folly::CancellationToken& cancelToken = 406 co_await folly::coro::co_current_cancellation_token; 407 const bool cancellable = cancelToken.canBeCancelled(); 408 apache::thrift::ClientReceiveState returnState; 409 apache::thrift::ClientSyncCallback<false> callback(&returnState); 410 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 411 auto [ctx, header] = nameCtx(rpcOptions); 412 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 413 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 414 static apache::thrift::RpcOptions defaultRpcOptions; 415 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 416 if constexpr (hasRpcOptions) { 417 nameImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 418 } else { 419 nameImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 420 } 421 if (cancellable) { 422 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 423 co_await callback.co_waitUntilDone(); 424 } else { 425 co_await callback.co_waitUntilDone(); 426 } 427 if (returnState.isException()) { 428 co_yield folly::coro::co_error(std::move(returnState.exception())); 429 } 430 returnState.resetProtocolId(protocolId); 431 returnState.resetCtx(std::move(ctx)); 432 SCOPE_EXIT { 433 if (hasRpcOptions && returnState.header()) { 434 auto* rheader = returnState.header(); 435 if (!rheader->getHeaders().empty()) { 436 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 437 } 438 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 439 } 440 }; 441 ::std::int32_t _return; 442 if (auto ew = recv_wrapped_name(_return, returnState)) { 443 co_yield folly::coro::co_error(std::move(ew)); 444 } 445 co_return _return; 446 } 447 public: 448 #endif // FOLLY_HAS_COROUTINES 449 450 virtual void name(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 451 452 453 static folly::exception_wrapper recv_wrapped_name(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 454 static ::std::int32_t recv_name(::apache::thrift::ClientReceiveState& state); 455 // Mock friendly virtual instance method 456 virtual ::std::int32_t recv_instance_name(::apache::thrift::ClientReceiveState& state); 457 virtual folly::exception_wrapper recv_instance_wrapped_name(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 458 private: 459 template <typename Protocol_, typename RpcOptions> 460 void nameT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 461 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> nameCtx(apache::thrift::RpcOptions* rpcOptions); 462 public: 463 virtual void name_to_value(std::unique_ptr<apache::thrift::RequestCallback> callback); 464 virtual void name_to_value(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 465 protected: 466 void name_to_valueImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 467 public: 468 469 virtual ::std::int32_t sync_name_to_value(); 470 virtual ::std::int32_t sync_name_to_value(apache::thrift::RpcOptions& rpcOptions); 471 472 virtual folly::Future<::std::int32_t> future_name_to_value(); 473 virtual folly::SemiFuture<::std::int32_t> semifuture_name_to_value(); 474 virtual folly::Future<::std::int32_t> future_name_to_value(apache::thrift::RpcOptions& rpcOptions); 475 virtual folly::SemiFuture<::std::int32_t> semifuture_name_to_value(apache::thrift::RpcOptions& rpcOptions); 476 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_name_to_value(apache::thrift::RpcOptions& rpcOptions); 477 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_name_to_value(apache::thrift::RpcOptions& rpcOptions); 478 479 #if FOLLY_HAS_COROUTINES 480 template <int = 0> co_name_to_value()481 folly::coro::Task<::std::int32_t> co_name_to_value() { 482 return co_name_to_value<false>(nullptr); 483 } 484 template <int = 0> co_name_to_value(apache::thrift::RpcOptions & rpcOptions)485 folly::coro::Task<::std::int32_t> co_name_to_value(apache::thrift::RpcOptions& rpcOptions) { 486 return co_name_to_value<true>(&rpcOptions); 487 } 488 private: 489 template <bool hasRpcOptions> co_name_to_value(apache::thrift::RpcOptions * rpcOptions)490 folly::coro::Task<::std::int32_t> co_name_to_value(apache::thrift::RpcOptions* rpcOptions) { 491 const folly::CancellationToken& cancelToken = 492 co_await folly::coro::co_current_cancellation_token; 493 const bool cancellable = cancelToken.canBeCancelled(); 494 apache::thrift::ClientReceiveState returnState; 495 apache::thrift::ClientSyncCallback<false> callback(&returnState); 496 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 497 auto [ctx, header] = name_to_valueCtx(rpcOptions); 498 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 499 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 500 static apache::thrift::RpcOptions defaultRpcOptions; 501 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 502 if constexpr (hasRpcOptions) { 503 name_to_valueImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 504 } else { 505 name_to_valueImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 506 } 507 if (cancellable) { 508 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 509 co_await callback.co_waitUntilDone(); 510 } else { 511 co_await callback.co_waitUntilDone(); 512 } 513 if (returnState.isException()) { 514 co_yield folly::coro::co_error(std::move(returnState.exception())); 515 } 516 returnState.resetProtocolId(protocolId); 517 returnState.resetCtx(std::move(ctx)); 518 SCOPE_EXIT { 519 if (hasRpcOptions && returnState.header()) { 520 auto* rheader = returnState.header(); 521 if (!rheader->getHeaders().empty()) { 522 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 523 } 524 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 525 } 526 }; 527 ::std::int32_t _return; 528 if (auto ew = recv_wrapped_name_to_value(_return, returnState)) { 529 co_yield folly::coro::co_error(std::move(ew)); 530 } 531 co_return _return; 532 } 533 public: 534 #endif // FOLLY_HAS_COROUTINES 535 536 virtual void name_to_value(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 537 538 539 static folly::exception_wrapper recv_wrapped_name_to_value(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 540 static ::std::int32_t recv_name_to_value(::apache::thrift::ClientReceiveState& state); 541 // Mock friendly virtual instance method 542 virtual ::std::int32_t recv_instance_name_to_value(::apache::thrift::ClientReceiveState& state); 543 virtual folly::exception_wrapper recv_instance_wrapped_name_to_value(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 544 private: 545 template <typename Protocol_, typename RpcOptions> 546 void name_to_valueT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 547 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> name_to_valueCtx(apache::thrift::RpcOptions* rpcOptions); 548 public: 549 virtual void names(std::unique_ptr<apache::thrift::RequestCallback> callback); 550 virtual void names(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 551 protected: 552 void namesImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 553 public: 554 555 virtual ::std::int32_t sync_names(); 556 virtual ::std::int32_t sync_names(apache::thrift::RpcOptions& rpcOptions); 557 558 virtual folly::Future<::std::int32_t> future_names(); 559 virtual folly::SemiFuture<::std::int32_t> semifuture_names(); 560 virtual folly::Future<::std::int32_t> future_names(apache::thrift::RpcOptions& rpcOptions); 561 virtual folly::SemiFuture<::std::int32_t> semifuture_names(apache::thrift::RpcOptions& rpcOptions); 562 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_names(apache::thrift::RpcOptions& rpcOptions); 563 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_names(apache::thrift::RpcOptions& rpcOptions); 564 565 #if FOLLY_HAS_COROUTINES 566 template <int = 0> co_names()567 folly::coro::Task<::std::int32_t> co_names() { 568 return co_names<false>(nullptr); 569 } 570 template <int = 0> co_names(apache::thrift::RpcOptions & rpcOptions)571 folly::coro::Task<::std::int32_t> co_names(apache::thrift::RpcOptions& rpcOptions) { 572 return co_names<true>(&rpcOptions); 573 } 574 private: 575 template <bool hasRpcOptions> co_names(apache::thrift::RpcOptions * rpcOptions)576 folly::coro::Task<::std::int32_t> co_names(apache::thrift::RpcOptions* rpcOptions) { 577 const folly::CancellationToken& cancelToken = 578 co_await folly::coro::co_current_cancellation_token; 579 const bool cancellable = cancelToken.canBeCancelled(); 580 apache::thrift::ClientReceiveState returnState; 581 apache::thrift::ClientSyncCallback<false> callback(&returnState); 582 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 583 auto [ctx, header] = namesCtx(rpcOptions); 584 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 585 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 586 static apache::thrift::RpcOptions defaultRpcOptions; 587 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 588 if constexpr (hasRpcOptions) { 589 namesImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 590 } else { 591 namesImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 592 } 593 if (cancellable) { 594 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 595 co_await callback.co_waitUntilDone(); 596 } else { 597 co_await callback.co_waitUntilDone(); 598 } 599 if (returnState.isException()) { 600 co_yield folly::coro::co_error(std::move(returnState.exception())); 601 } 602 returnState.resetProtocolId(protocolId); 603 returnState.resetCtx(std::move(ctx)); 604 SCOPE_EXIT { 605 if (hasRpcOptions && returnState.header()) { 606 auto* rheader = returnState.header(); 607 if (!rheader->getHeaders().empty()) { 608 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 609 } 610 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 611 } 612 }; 613 ::std::int32_t _return; 614 if (auto ew = recv_wrapped_names(_return, returnState)) { 615 co_yield folly::coro::co_error(std::move(ew)); 616 } 617 co_return _return; 618 } 619 public: 620 #endif // FOLLY_HAS_COROUTINES 621 622 virtual void names(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 623 624 625 static folly::exception_wrapper recv_wrapped_names(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 626 static ::std::int32_t recv_names(::apache::thrift::ClientReceiveState& state); 627 // Mock friendly virtual instance method 628 virtual ::std::int32_t recv_instance_names(::apache::thrift::ClientReceiveState& state); 629 virtual folly::exception_wrapper recv_instance_wrapped_names(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 630 private: 631 template <typename Protocol_, typename RpcOptions> 632 void namesT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 633 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> namesCtx(apache::thrift::RpcOptions* rpcOptions); 634 public: 635 virtual void prefix_tree(std::unique_ptr<apache::thrift::RequestCallback> callback); 636 virtual void prefix_tree(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 637 protected: 638 void prefix_treeImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 639 public: 640 641 virtual ::std::int32_t sync_prefix_tree(); 642 virtual ::std::int32_t sync_prefix_tree(apache::thrift::RpcOptions& rpcOptions); 643 644 virtual folly::Future<::std::int32_t> future_prefix_tree(); 645 virtual folly::SemiFuture<::std::int32_t> semifuture_prefix_tree(); 646 virtual folly::Future<::std::int32_t> future_prefix_tree(apache::thrift::RpcOptions& rpcOptions); 647 virtual folly::SemiFuture<::std::int32_t> semifuture_prefix_tree(apache::thrift::RpcOptions& rpcOptions); 648 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_prefix_tree(apache::thrift::RpcOptions& rpcOptions); 649 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_prefix_tree(apache::thrift::RpcOptions& rpcOptions); 650 651 #if FOLLY_HAS_COROUTINES 652 template <int = 0> co_prefix_tree()653 folly::coro::Task<::std::int32_t> co_prefix_tree() { 654 return co_prefix_tree<false>(nullptr); 655 } 656 template <int = 0> co_prefix_tree(apache::thrift::RpcOptions & rpcOptions)657 folly::coro::Task<::std::int32_t> co_prefix_tree(apache::thrift::RpcOptions& rpcOptions) { 658 return co_prefix_tree<true>(&rpcOptions); 659 } 660 private: 661 template <bool hasRpcOptions> co_prefix_tree(apache::thrift::RpcOptions * rpcOptions)662 folly::coro::Task<::std::int32_t> co_prefix_tree(apache::thrift::RpcOptions* rpcOptions) { 663 const folly::CancellationToken& cancelToken = 664 co_await folly::coro::co_current_cancellation_token; 665 const bool cancellable = cancelToken.canBeCancelled(); 666 apache::thrift::ClientReceiveState returnState; 667 apache::thrift::ClientSyncCallback<false> callback(&returnState); 668 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 669 auto [ctx, header] = prefix_treeCtx(rpcOptions); 670 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 671 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 672 static apache::thrift::RpcOptions defaultRpcOptions; 673 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 674 if constexpr (hasRpcOptions) { 675 prefix_treeImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 676 } else { 677 prefix_treeImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 678 } 679 if (cancellable) { 680 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 681 co_await callback.co_waitUntilDone(); 682 } else { 683 co_await callback.co_waitUntilDone(); 684 } 685 if (returnState.isException()) { 686 co_yield folly::coro::co_error(std::move(returnState.exception())); 687 } 688 returnState.resetProtocolId(protocolId); 689 returnState.resetCtx(std::move(ctx)); 690 SCOPE_EXIT { 691 if (hasRpcOptions && returnState.header()) { 692 auto* rheader = returnState.header(); 693 if (!rheader->getHeaders().empty()) { 694 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 695 } 696 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 697 } 698 }; 699 ::std::int32_t _return; 700 if (auto ew = recv_wrapped_prefix_tree(_return, returnState)) { 701 co_yield folly::coro::co_error(std::move(ew)); 702 } 703 co_return _return; 704 } 705 public: 706 #endif // FOLLY_HAS_COROUTINES 707 708 virtual void prefix_tree(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 709 710 711 static folly::exception_wrapper recv_wrapped_prefix_tree(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 712 static ::std::int32_t recv_prefix_tree(::apache::thrift::ClientReceiveState& state); 713 // Mock friendly virtual instance method 714 virtual ::std::int32_t recv_instance_prefix_tree(::apache::thrift::ClientReceiveState& state); 715 virtual folly::exception_wrapper recv_instance_wrapped_prefix_tree(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 716 private: 717 template <typename Protocol_, typename RpcOptions> 718 void prefix_treeT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 719 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> prefix_treeCtx(apache::thrift::RpcOptions* rpcOptions); 720 public: 721 virtual void sets(std::unique_ptr<apache::thrift::RequestCallback> callback); 722 virtual void sets(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 723 protected: 724 void setsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 725 public: 726 727 virtual ::std::int32_t sync_sets(); 728 virtual ::std::int32_t sync_sets(apache::thrift::RpcOptions& rpcOptions); 729 730 virtual folly::Future<::std::int32_t> future_sets(); 731 virtual folly::SemiFuture<::std::int32_t> semifuture_sets(); 732 virtual folly::Future<::std::int32_t> future_sets(apache::thrift::RpcOptions& rpcOptions); 733 virtual folly::SemiFuture<::std::int32_t> semifuture_sets(apache::thrift::RpcOptions& rpcOptions); 734 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_sets(apache::thrift::RpcOptions& rpcOptions); 735 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_sets(apache::thrift::RpcOptions& rpcOptions); 736 737 #if FOLLY_HAS_COROUTINES 738 template <int = 0> co_sets()739 folly::coro::Task<::std::int32_t> co_sets() { 740 return co_sets<false>(nullptr); 741 } 742 template <int = 0> co_sets(apache::thrift::RpcOptions & rpcOptions)743 folly::coro::Task<::std::int32_t> co_sets(apache::thrift::RpcOptions& rpcOptions) { 744 return co_sets<true>(&rpcOptions); 745 } 746 private: 747 template <bool hasRpcOptions> co_sets(apache::thrift::RpcOptions * rpcOptions)748 folly::coro::Task<::std::int32_t> co_sets(apache::thrift::RpcOptions* rpcOptions) { 749 const folly::CancellationToken& cancelToken = 750 co_await folly::coro::co_current_cancellation_token; 751 const bool cancellable = cancelToken.canBeCancelled(); 752 apache::thrift::ClientReceiveState returnState; 753 apache::thrift::ClientSyncCallback<false> callback(&returnState); 754 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 755 auto [ctx, header] = setsCtx(rpcOptions); 756 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 757 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 758 static apache::thrift::RpcOptions defaultRpcOptions; 759 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 760 if constexpr (hasRpcOptions) { 761 setsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 762 } else { 763 setsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 764 } 765 if (cancellable) { 766 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 767 co_await callback.co_waitUntilDone(); 768 } else { 769 co_await callback.co_waitUntilDone(); 770 } 771 if (returnState.isException()) { 772 co_yield folly::coro::co_error(std::move(returnState.exception())); 773 } 774 returnState.resetProtocolId(protocolId); 775 returnState.resetCtx(std::move(ctx)); 776 SCOPE_EXIT { 777 if (hasRpcOptions && returnState.header()) { 778 auto* rheader = returnState.header(); 779 if (!rheader->getHeaders().empty()) { 780 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 781 } 782 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 783 } 784 }; 785 ::std::int32_t _return; 786 if (auto ew = recv_wrapped_sets(_return, returnState)) { 787 co_yield folly::coro::co_error(std::move(ew)); 788 } 789 co_return _return; 790 } 791 public: 792 #endif // FOLLY_HAS_COROUTINES 793 794 virtual void sets(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 795 796 797 static folly::exception_wrapper recv_wrapped_sets(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 798 static ::std::int32_t recv_sets(::apache::thrift::ClientReceiveState& state); 799 // Mock friendly virtual instance method 800 virtual ::std::int32_t recv_instance_sets(::apache::thrift::ClientReceiveState& state); 801 virtual folly::exception_wrapper recv_instance_wrapped_sets(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 802 private: 803 template <typename Protocol_, typename RpcOptions> 804 void setsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 805 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> setsCtx(apache::thrift::RpcOptions* rpcOptions); 806 public: 807 virtual void setter(std::unique_ptr<apache::thrift::RequestCallback> callback); 808 virtual void setter(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 809 protected: 810 void setterImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 811 public: 812 813 virtual ::std::int32_t sync_setter(); 814 virtual ::std::int32_t sync_setter(apache::thrift::RpcOptions& rpcOptions); 815 816 virtual folly::Future<::std::int32_t> future_setter(); 817 virtual folly::SemiFuture<::std::int32_t> semifuture_setter(); 818 virtual folly::Future<::std::int32_t> future_setter(apache::thrift::RpcOptions& rpcOptions); 819 virtual folly::SemiFuture<::std::int32_t> semifuture_setter(apache::thrift::RpcOptions& rpcOptions); 820 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_setter(apache::thrift::RpcOptions& rpcOptions); 821 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_setter(apache::thrift::RpcOptions& rpcOptions); 822 823 #if FOLLY_HAS_COROUTINES 824 template <int = 0> co_setter()825 folly::coro::Task<::std::int32_t> co_setter() { 826 return co_setter<false>(nullptr); 827 } 828 template <int = 0> co_setter(apache::thrift::RpcOptions & rpcOptions)829 folly::coro::Task<::std::int32_t> co_setter(apache::thrift::RpcOptions& rpcOptions) { 830 return co_setter<true>(&rpcOptions); 831 } 832 private: 833 template <bool hasRpcOptions> co_setter(apache::thrift::RpcOptions * rpcOptions)834 folly::coro::Task<::std::int32_t> co_setter(apache::thrift::RpcOptions* rpcOptions) { 835 const folly::CancellationToken& cancelToken = 836 co_await folly::coro::co_current_cancellation_token; 837 const bool cancellable = cancelToken.canBeCancelled(); 838 apache::thrift::ClientReceiveState returnState; 839 apache::thrift::ClientSyncCallback<false> callback(&returnState); 840 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 841 auto [ctx, header] = setterCtx(rpcOptions); 842 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 843 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 844 static apache::thrift::RpcOptions defaultRpcOptions; 845 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 846 if constexpr (hasRpcOptions) { 847 setterImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 848 } else { 849 setterImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 850 } 851 if (cancellable) { 852 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 853 co_await callback.co_waitUntilDone(); 854 } else { 855 co_await callback.co_waitUntilDone(); 856 } 857 if (returnState.isException()) { 858 co_yield folly::coro::co_error(std::move(returnState.exception())); 859 } 860 returnState.resetProtocolId(protocolId); 861 returnState.resetCtx(std::move(ctx)); 862 SCOPE_EXIT { 863 if (hasRpcOptions && returnState.header()) { 864 auto* rheader = returnState.header(); 865 if (!rheader->getHeaders().empty()) { 866 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 867 } 868 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 869 } 870 }; 871 ::std::int32_t _return; 872 if (auto ew = recv_wrapped_setter(_return, returnState)) { 873 co_yield folly::coro::co_error(std::move(ew)); 874 } 875 co_return _return; 876 } 877 public: 878 #endif // FOLLY_HAS_COROUTINES 879 880 virtual void setter(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 881 882 883 static folly::exception_wrapper recv_wrapped_setter(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 884 static ::std::int32_t recv_setter(::apache::thrift::ClientReceiveState& state); 885 // Mock friendly virtual instance method 886 virtual ::std::int32_t recv_instance_setter(::apache::thrift::ClientReceiveState& state); 887 virtual folly::exception_wrapper recv_instance_wrapped_setter(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 888 private: 889 template <typename Protocol_, typename RpcOptions> 890 void setterT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 891 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> setterCtx(apache::thrift::RpcOptions* rpcOptions); 892 public: 893 virtual void str(std::unique_ptr<apache::thrift::RequestCallback> callback); 894 virtual void str(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 895 protected: 896 void strImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 897 public: 898 899 virtual ::std::int32_t sync_str(); 900 virtual ::std::int32_t sync_str(apache::thrift::RpcOptions& rpcOptions); 901 902 virtual folly::Future<::std::int32_t> future_str(); 903 virtual folly::SemiFuture<::std::int32_t> semifuture_str(); 904 virtual folly::Future<::std::int32_t> future_str(apache::thrift::RpcOptions& rpcOptions); 905 virtual folly::SemiFuture<::std::int32_t> semifuture_str(apache::thrift::RpcOptions& rpcOptions); 906 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_str(apache::thrift::RpcOptions& rpcOptions); 907 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_str(apache::thrift::RpcOptions& rpcOptions); 908 909 #if FOLLY_HAS_COROUTINES 910 template <int = 0> co_str()911 folly::coro::Task<::std::int32_t> co_str() { 912 return co_str<false>(nullptr); 913 } 914 template <int = 0> co_str(apache::thrift::RpcOptions & rpcOptions)915 folly::coro::Task<::std::int32_t> co_str(apache::thrift::RpcOptions& rpcOptions) { 916 return co_str<true>(&rpcOptions); 917 } 918 private: 919 template <bool hasRpcOptions> co_str(apache::thrift::RpcOptions * rpcOptions)920 folly::coro::Task<::std::int32_t> co_str(apache::thrift::RpcOptions* rpcOptions) { 921 const folly::CancellationToken& cancelToken = 922 co_await folly::coro::co_current_cancellation_token; 923 const bool cancellable = cancelToken.canBeCancelled(); 924 apache::thrift::ClientReceiveState returnState; 925 apache::thrift::ClientSyncCallback<false> callback(&returnState); 926 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 927 auto [ctx, header] = strCtx(rpcOptions); 928 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 929 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 930 static apache::thrift::RpcOptions defaultRpcOptions; 931 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 932 if constexpr (hasRpcOptions) { 933 strImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 934 } else { 935 strImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 936 } 937 if (cancellable) { 938 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 939 co_await callback.co_waitUntilDone(); 940 } else { 941 co_await callback.co_waitUntilDone(); 942 } 943 if (returnState.isException()) { 944 co_yield folly::coro::co_error(std::move(returnState.exception())); 945 } 946 returnState.resetProtocolId(protocolId); 947 returnState.resetCtx(std::move(ctx)); 948 SCOPE_EXIT { 949 if (hasRpcOptions && returnState.header()) { 950 auto* rheader = returnState.header(); 951 if (!rheader->getHeaders().empty()) { 952 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 953 } 954 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 955 } 956 }; 957 ::std::int32_t _return; 958 if (auto ew = recv_wrapped_str(_return, returnState)) { 959 co_yield folly::coro::co_error(std::move(ew)); 960 } 961 co_return _return; 962 } 963 public: 964 #endif // FOLLY_HAS_COROUTINES 965 966 virtual void str(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 967 968 969 static folly::exception_wrapper recv_wrapped_str(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 970 static ::std::int32_t recv_str(::apache::thrift::ClientReceiveState& state); 971 // Mock friendly virtual instance method 972 virtual ::std::int32_t recv_instance_str(::apache::thrift::ClientReceiveState& state); 973 virtual folly::exception_wrapper recv_instance_wrapped_str(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 974 private: 975 template <typename Protocol_, typename RpcOptions> 976 void strT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 977 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> strCtx(apache::thrift::RpcOptions* rpcOptions); 978 public: 979 virtual void strings(std::unique_ptr<apache::thrift::RequestCallback> callback); 980 virtual void strings(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 981 protected: 982 void stringsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 983 public: 984 985 virtual ::std::int32_t sync_strings(); 986 virtual ::std::int32_t sync_strings(apache::thrift::RpcOptions& rpcOptions); 987 988 virtual folly::Future<::std::int32_t> future_strings(); 989 virtual folly::SemiFuture<::std::int32_t> semifuture_strings(); 990 virtual folly::Future<::std::int32_t> future_strings(apache::thrift::RpcOptions& rpcOptions); 991 virtual folly::SemiFuture<::std::int32_t> semifuture_strings(apache::thrift::RpcOptions& rpcOptions); 992 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_strings(apache::thrift::RpcOptions& rpcOptions); 993 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_strings(apache::thrift::RpcOptions& rpcOptions); 994 995 #if FOLLY_HAS_COROUTINES 996 template <int = 0> co_strings()997 folly::coro::Task<::std::int32_t> co_strings() { 998 return co_strings<false>(nullptr); 999 } 1000 template <int = 0> co_strings(apache::thrift::RpcOptions & rpcOptions)1001 folly::coro::Task<::std::int32_t> co_strings(apache::thrift::RpcOptions& rpcOptions) { 1002 return co_strings<true>(&rpcOptions); 1003 } 1004 private: 1005 template <bool hasRpcOptions> co_strings(apache::thrift::RpcOptions * rpcOptions)1006 folly::coro::Task<::std::int32_t> co_strings(apache::thrift::RpcOptions* rpcOptions) { 1007 const folly::CancellationToken& cancelToken = 1008 co_await folly::coro::co_current_cancellation_token; 1009 const bool cancellable = cancelToken.canBeCancelled(); 1010 apache::thrift::ClientReceiveState returnState; 1011 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1012 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1013 auto [ctx, header] = stringsCtx(rpcOptions); 1014 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1015 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1016 static apache::thrift::RpcOptions defaultRpcOptions; 1017 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1018 if constexpr (hasRpcOptions) { 1019 stringsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1020 } else { 1021 stringsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1022 } 1023 if (cancellable) { 1024 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1025 co_await callback.co_waitUntilDone(); 1026 } else { 1027 co_await callback.co_waitUntilDone(); 1028 } 1029 if (returnState.isException()) { 1030 co_yield folly::coro::co_error(std::move(returnState.exception())); 1031 } 1032 returnState.resetProtocolId(protocolId); 1033 returnState.resetCtx(std::move(ctx)); 1034 SCOPE_EXIT { 1035 if (hasRpcOptions && returnState.header()) { 1036 auto* rheader = returnState.header(); 1037 if (!rheader->getHeaders().empty()) { 1038 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1039 } 1040 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1041 } 1042 }; 1043 ::std::int32_t _return; 1044 if (auto ew = recv_wrapped_strings(_return, returnState)) { 1045 co_yield folly::coro::co_error(std::move(ew)); 1046 } 1047 co_return _return; 1048 } 1049 public: 1050 #endif // FOLLY_HAS_COROUTINES 1051 1052 virtual void strings(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1053 1054 1055 static folly::exception_wrapper recv_wrapped_strings(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1056 static ::std::int32_t recv_strings(::apache::thrift::ClientReceiveState& state); 1057 // Mock friendly virtual instance method 1058 virtual ::std::int32_t recv_instance_strings(::apache::thrift::ClientReceiveState& state); 1059 virtual folly::exception_wrapper recv_instance_wrapped_strings(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1060 private: 1061 template <typename Protocol_, typename RpcOptions> 1062 void stringsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1063 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> stringsCtx(apache::thrift::RpcOptions* rpcOptions); 1064 public: 1065 virtual void type(std::unique_ptr<apache::thrift::RequestCallback> callback); 1066 virtual void type(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1067 protected: 1068 void typeImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1069 public: 1070 1071 virtual ::std::int32_t sync_type(); 1072 virtual ::std::int32_t sync_type(apache::thrift::RpcOptions& rpcOptions); 1073 1074 virtual folly::Future<::std::int32_t> future_type(); 1075 virtual folly::SemiFuture<::std::int32_t> semifuture_type(); 1076 virtual folly::Future<::std::int32_t> future_type(apache::thrift::RpcOptions& rpcOptions); 1077 virtual folly::SemiFuture<::std::int32_t> semifuture_type(apache::thrift::RpcOptions& rpcOptions); 1078 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_type(apache::thrift::RpcOptions& rpcOptions); 1079 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_type(apache::thrift::RpcOptions& rpcOptions); 1080 1081 #if FOLLY_HAS_COROUTINES 1082 template <int = 0> co_type()1083 folly::coro::Task<::std::int32_t> co_type() { 1084 return co_type<false>(nullptr); 1085 } 1086 template <int = 0> co_type(apache::thrift::RpcOptions & rpcOptions)1087 folly::coro::Task<::std::int32_t> co_type(apache::thrift::RpcOptions& rpcOptions) { 1088 return co_type<true>(&rpcOptions); 1089 } 1090 private: 1091 template <bool hasRpcOptions> co_type(apache::thrift::RpcOptions * rpcOptions)1092 folly::coro::Task<::std::int32_t> co_type(apache::thrift::RpcOptions* rpcOptions) { 1093 const folly::CancellationToken& cancelToken = 1094 co_await folly::coro::co_current_cancellation_token; 1095 const bool cancellable = cancelToken.canBeCancelled(); 1096 apache::thrift::ClientReceiveState returnState; 1097 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1098 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1099 auto [ctx, header] = typeCtx(rpcOptions); 1100 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1101 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1102 static apache::thrift::RpcOptions defaultRpcOptions; 1103 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1104 if constexpr (hasRpcOptions) { 1105 typeImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1106 } else { 1107 typeImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1108 } 1109 if (cancellable) { 1110 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1111 co_await callback.co_waitUntilDone(); 1112 } else { 1113 co_await callback.co_waitUntilDone(); 1114 } 1115 if (returnState.isException()) { 1116 co_yield folly::coro::co_error(std::move(returnState.exception())); 1117 } 1118 returnState.resetProtocolId(protocolId); 1119 returnState.resetCtx(std::move(ctx)); 1120 SCOPE_EXIT { 1121 if (hasRpcOptions && returnState.header()) { 1122 auto* rheader = returnState.header(); 1123 if (!rheader->getHeaders().empty()) { 1124 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1125 } 1126 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1127 } 1128 }; 1129 ::std::int32_t _return; 1130 if (auto ew = recv_wrapped_type(_return, returnState)) { 1131 co_yield folly::coro::co_error(std::move(ew)); 1132 } 1133 co_return _return; 1134 } 1135 public: 1136 #endif // FOLLY_HAS_COROUTINES 1137 1138 virtual void type(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1139 1140 1141 static folly::exception_wrapper recv_wrapped_type(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1142 static ::std::int32_t recv_type(::apache::thrift::ClientReceiveState& state); 1143 // Mock friendly virtual instance method 1144 virtual ::std::int32_t recv_instance_type(::apache::thrift::ClientReceiveState& state); 1145 virtual folly::exception_wrapper recv_instance_wrapped_type(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1146 private: 1147 template <typename Protocol_, typename RpcOptions> 1148 void typeT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1149 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> typeCtx(apache::thrift::RpcOptions* rpcOptions); 1150 public: 1151 virtual void value(std::unique_ptr<apache::thrift::RequestCallback> callback); 1152 virtual void value(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1153 protected: 1154 void valueImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1155 public: 1156 1157 virtual ::std::int32_t sync_value(); 1158 virtual ::std::int32_t sync_value(apache::thrift::RpcOptions& rpcOptions); 1159 1160 virtual folly::Future<::std::int32_t> future_value(); 1161 virtual folly::SemiFuture<::std::int32_t> semifuture_value(); 1162 virtual folly::Future<::std::int32_t> future_value(apache::thrift::RpcOptions& rpcOptions); 1163 virtual folly::SemiFuture<::std::int32_t> semifuture_value(apache::thrift::RpcOptions& rpcOptions); 1164 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_value(apache::thrift::RpcOptions& rpcOptions); 1165 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_value(apache::thrift::RpcOptions& rpcOptions); 1166 1167 #if FOLLY_HAS_COROUTINES 1168 template <int = 0> co_value()1169 folly::coro::Task<::std::int32_t> co_value() { 1170 return co_value<false>(nullptr); 1171 } 1172 template <int = 0> co_value(apache::thrift::RpcOptions & rpcOptions)1173 folly::coro::Task<::std::int32_t> co_value(apache::thrift::RpcOptions& rpcOptions) { 1174 return co_value<true>(&rpcOptions); 1175 } 1176 private: 1177 template <bool hasRpcOptions> co_value(apache::thrift::RpcOptions * rpcOptions)1178 folly::coro::Task<::std::int32_t> co_value(apache::thrift::RpcOptions* rpcOptions) { 1179 const folly::CancellationToken& cancelToken = 1180 co_await folly::coro::co_current_cancellation_token; 1181 const bool cancellable = cancelToken.canBeCancelled(); 1182 apache::thrift::ClientReceiveState returnState; 1183 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1184 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1185 auto [ctx, header] = valueCtx(rpcOptions); 1186 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1187 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1188 static apache::thrift::RpcOptions defaultRpcOptions; 1189 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1190 if constexpr (hasRpcOptions) { 1191 valueImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1192 } else { 1193 valueImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1194 } 1195 if (cancellable) { 1196 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1197 co_await callback.co_waitUntilDone(); 1198 } else { 1199 co_await callback.co_waitUntilDone(); 1200 } 1201 if (returnState.isException()) { 1202 co_yield folly::coro::co_error(std::move(returnState.exception())); 1203 } 1204 returnState.resetProtocolId(protocolId); 1205 returnState.resetCtx(std::move(ctx)); 1206 SCOPE_EXIT { 1207 if (hasRpcOptions && returnState.header()) { 1208 auto* rheader = returnState.header(); 1209 if (!rheader->getHeaders().empty()) { 1210 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1211 } 1212 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1213 } 1214 }; 1215 ::std::int32_t _return; 1216 if (auto ew = recv_wrapped_value(_return, returnState)) { 1217 co_yield folly::coro::co_error(std::move(ew)); 1218 } 1219 co_return _return; 1220 } 1221 public: 1222 #endif // FOLLY_HAS_COROUTINES 1223 1224 virtual void value(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1225 1226 1227 static folly::exception_wrapper recv_wrapped_value(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1228 static ::std::int32_t recv_value(::apache::thrift::ClientReceiveState& state); 1229 // Mock friendly virtual instance method 1230 virtual ::std::int32_t recv_instance_value(::apache::thrift::ClientReceiveState& state); 1231 virtual folly::exception_wrapper recv_instance_wrapped_value(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1232 private: 1233 template <typename Protocol_, typename RpcOptions> 1234 void valueT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1235 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> valueCtx(apache::thrift::RpcOptions* rpcOptions); 1236 public: 1237 virtual void value_to_name(std::unique_ptr<apache::thrift::RequestCallback> callback); 1238 virtual void value_to_name(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1239 protected: 1240 void value_to_nameImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1241 public: 1242 1243 virtual ::std::int32_t sync_value_to_name(); 1244 virtual ::std::int32_t sync_value_to_name(apache::thrift::RpcOptions& rpcOptions); 1245 1246 virtual folly::Future<::std::int32_t> future_value_to_name(); 1247 virtual folly::SemiFuture<::std::int32_t> semifuture_value_to_name(); 1248 virtual folly::Future<::std::int32_t> future_value_to_name(apache::thrift::RpcOptions& rpcOptions); 1249 virtual folly::SemiFuture<::std::int32_t> semifuture_value_to_name(apache::thrift::RpcOptions& rpcOptions); 1250 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_value_to_name(apache::thrift::RpcOptions& rpcOptions); 1251 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_value_to_name(apache::thrift::RpcOptions& rpcOptions); 1252 1253 #if FOLLY_HAS_COROUTINES 1254 template <int = 0> co_value_to_name()1255 folly::coro::Task<::std::int32_t> co_value_to_name() { 1256 return co_value_to_name<false>(nullptr); 1257 } 1258 template <int = 0> co_value_to_name(apache::thrift::RpcOptions & rpcOptions)1259 folly::coro::Task<::std::int32_t> co_value_to_name(apache::thrift::RpcOptions& rpcOptions) { 1260 return co_value_to_name<true>(&rpcOptions); 1261 } 1262 private: 1263 template <bool hasRpcOptions> co_value_to_name(apache::thrift::RpcOptions * rpcOptions)1264 folly::coro::Task<::std::int32_t> co_value_to_name(apache::thrift::RpcOptions* rpcOptions) { 1265 const folly::CancellationToken& cancelToken = 1266 co_await folly::coro::co_current_cancellation_token; 1267 const bool cancellable = cancelToken.canBeCancelled(); 1268 apache::thrift::ClientReceiveState returnState; 1269 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1270 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1271 auto [ctx, header] = value_to_nameCtx(rpcOptions); 1272 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1273 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1274 static apache::thrift::RpcOptions defaultRpcOptions; 1275 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1276 if constexpr (hasRpcOptions) { 1277 value_to_nameImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1278 } else { 1279 value_to_nameImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1280 } 1281 if (cancellable) { 1282 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1283 co_await callback.co_waitUntilDone(); 1284 } else { 1285 co_await callback.co_waitUntilDone(); 1286 } 1287 if (returnState.isException()) { 1288 co_yield folly::coro::co_error(std::move(returnState.exception())); 1289 } 1290 returnState.resetProtocolId(protocolId); 1291 returnState.resetCtx(std::move(ctx)); 1292 SCOPE_EXIT { 1293 if (hasRpcOptions && returnState.header()) { 1294 auto* rheader = returnState.header(); 1295 if (!rheader->getHeaders().empty()) { 1296 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1297 } 1298 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1299 } 1300 }; 1301 ::std::int32_t _return; 1302 if (auto ew = recv_wrapped_value_to_name(_return, returnState)) { 1303 co_yield folly::coro::co_error(std::move(ew)); 1304 } 1305 co_return _return; 1306 } 1307 public: 1308 #endif // FOLLY_HAS_COROUTINES 1309 1310 virtual void value_to_name(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1311 1312 1313 static folly::exception_wrapper recv_wrapped_value_to_name(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1314 static ::std::int32_t recv_value_to_name(::apache::thrift::ClientReceiveState& state); 1315 // Mock friendly virtual instance method 1316 virtual ::std::int32_t recv_instance_value_to_name(::apache::thrift::ClientReceiveState& state); 1317 virtual folly::exception_wrapper recv_instance_wrapped_value_to_name(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1318 private: 1319 template <typename Protocol_, typename RpcOptions> 1320 void value_to_nameT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1321 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> value_to_nameCtx(apache::thrift::RpcOptions* rpcOptions); 1322 public: 1323 virtual void values(std::unique_ptr<apache::thrift::RequestCallback> callback); 1324 virtual void values(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1325 protected: 1326 void valuesImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1327 public: 1328 1329 virtual ::std::int32_t sync_values(); 1330 virtual ::std::int32_t sync_values(apache::thrift::RpcOptions& rpcOptions); 1331 1332 virtual folly::Future<::std::int32_t> future_values(); 1333 virtual folly::SemiFuture<::std::int32_t> semifuture_values(); 1334 virtual folly::Future<::std::int32_t> future_values(apache::thrift::RpcOptions& rpcOptions); 1335 virtual folly::SemiFuture<::std::int32_t> semifuture_values(apache::thrift::RpcOptions& rpcOptions); 1336 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_values(apache::thrift::RpcOptions& rpcOptions); 1337 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_values(apache::thrift::RpcOptions& rpcOptions); 1338 1339 #if FOLLY_HAS_COROUTINES 1340 template <int = 0> co_values()1341 folly::coro::Task<::std::int32_t> co_values() { 1342 return co_values<false>(nullptr); 1343 } 1344 template <int = 0> co_values(apache::thrift::RpcOptions & rpcOptions)1345 folly::coro::Task<::std::int32_t> co_values(apache::thrift::RpcOptions& rpcOptions) { 1346 return co_values<true>(&rpcOptions); 1347 } 1348 private: 1349 template <bool hasRpcOptions> co_values(apache::thrift::RpcOptions * rpcOptions)1350 folly::coro::Task<::std::int32_t> co_values(apache::thrift::RpcOptions* rpcOptions) { 1351 const folly::CancellationToken& cancelToken = 1352 co_await folly::coro::co_current_cancellation_token; 1353 const bool cancellable = cancelToken.canBeCancelled(); 1354 apache::thrift::ClientReceiveState returnState; 1355 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1356 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1357 auto [ctx, header] = valuesCtx(rpcOptions); 1358 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1359 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1360 static apache::thrift::RpcOptions defaultRpcOptions; 1361 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1362 if constexpr (hasRpcOptions) { 1363 valuesImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1364 } else { 1365 valuesImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1366 } 1367 if (cancellable) { 1368 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1369 co_await callback.co_waitUntilDone(); 1370 } else { 1371 co_await callback.co_waitUntilDone(); 1372 } 1373 if (returnState.isException()) { 1374 co_yield folly::coro::co_error(std::move(returnState.exception())); 1375 } 1376 returnState.resetProtocolId(protocolId); 1377 returnState.resetCtx(std::move(ctx)); 1378 SCOPE_EXIT { 1379 if (hasRpcOptions && returnState.header()) { 1380 auto* rheader = returnState.header(); 1381 if (!rheader->getHeaders().empty()) { 1382 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1383 } 1384 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1385 } 1386 }; 1387 ::std::int32_t _return; 1388 if (auto ew = recv_wrapped_values(_return, returnState)) { 1389 co_yield folly::coro::co_error(std::move(ew)); 1390 } 1391 co_return _return; 1392 } 1393 public: 1394 #endif // FOLLY_HAS_COROUTINES 1395 1396 virtual void values(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1397 1398 1399 static folly::exception_wrapper recv_wrapped_values(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1400 static ::std::int32_t recv_values(::apache::thrift::ClientReceiveState& state); 1401 // Mock friendly virtual instance method 1402 virtual ::std::int32_t recv_instance_values(::apache::thrift::ClientReceiveState& state); 1403 virtual folly::exception_wrapper recv_instance_wrapped_values(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1404 private: 1405 template <typename Protocol_, typename RpcOptions> 1406 void valuesT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1407 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> valuesCtx(apache::thrift::RpcOptions* rpcOptions); 1408 public: 1409 virtual void id(std::unique_ptr<apache::thrift::RequestCallback> callback); 1410 virtual void id(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1411 protected: 1412 void idImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1413 public: 1414 1415 virtual ::std::int32_t sync_id(); 1416 virtual ::std::int32_t sync_id(apache::thrift::RpcOptions& rpcOptions); 1417 1418 virtual folly::Future<::std::int32_t> future_id(); 1419 virtual folly::SemiFuture<::std::int32_t> semifuture_id(); 1420 virtual folly::Future<::std::int32_t> future_id(apache::thrift::RpcOptions& rpcOptions); 1421 virtual folly::SemiFuture<::std::int32_t> semifuture_id(apache::thrift::RpcOptions& rpcOptions); 1422 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_id(apache::thrift::RpcOptions& rpcOptions); 1423 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_id(apache::thrift::RpcOptions& rpcOptions); 1424 1425 #if FOLLY_HAS_COROUTINES 1426 template <int = 0> co_id()1427 folly::coro::Task<::std::int32_t> co_id() { 1428 return co_id<false>(nullptr); 1429 } 1430 template <int = 0> co_id(apache::thrift::RpcOptions & rpcOptions)1431 folly::coro::Task<::std::int32_t> co_id(apache::thrift::RpcOptions& rpcOptions) { 1432 return co_id<true>(&rpcOptions); 1433 } 1434 private: 1435 template <bool hasRpcOptions> co_id(apache::thrift::RpcOptions * rpcOptions)1436 folly::coro::Task<::std::int32_t> co_id(apache::thrift::RpcOptions* rpcOptions) { 1437 const folly::CancellationToken& cancelToken = 1438 co_await folly::coro::co_current_cancellation_token; 1439 const bool cancellable = cancelToken.canBeCancelled(); 1440 apache::thrift::ClientReceiveState returnState; 1441 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1442 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1443 auto [ctx, header] = idCtx(rpcOptions); 1444 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1445 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1446 static apache::thrift::RpcOptions defaultRpcOptions; 1447 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1448 if constexpr (hasRpcOptions) { 1449 idImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1450 } else { 1451 idImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1452 } 1453 if (cancellable) { 1454 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1455 co_await callback.co_waitUntilDone(); 1456 } else { 1457 co_await callback.co_waitUntilDone(); 1458 } 1459 if (returnState.isException()) { 1460 co_yield folly::coro::co_error(std::move(returnState.exception())); 1461 } 1462 returnState.resetProtocolId(protocolId); 1463 returnState.resetCtx(std::move(ctx)); 1464 SCOPE_EXIT { 1465 if (hasRpcOptions && returnState.header()) { 1466 auto* rheader = returnState.header(); 1467 if (!rheader->getHeaders().empty()) { 1468 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1469 } 1470 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1471 } 1472 }; 1473 ::std::int32_t _return; 1474 if (auto ew = recv_wrapped_id(_return, returnState)) { 1475 co_yield folly::coro::co_error(std::move(ew)); 1476 } 1477 co_return _return; 1478 } 1479 public: 1480 #endif // FOLLY_HAS_COROUTINES 1481 1482 virtual void id(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1483 1484 1485 static folly::exception_wrapper recv_wrapped_id(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1486 static ::std::int32_t recv_id(::apache::thrift::ClientReceiveState& state); 1487 // Mock friendly virtual instance method 1488 virtual ::std::int32_t recv_instance_id(::apache::thrift::ClientReceiveState& state); 1489 virtual folly::exception_wrapper recv_instance_wrapped_id(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1490 private: 1491 template <typename Protocol_, typename RpcOptions> 1492 void idT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1493 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> idCtx(apache::thrift::RpcOptions* rpcOptions); 1494 public: 1495 virtual void ids(std::unique_ptr<apache::thrift::RequestCallback> callback); 1496 virtual void ids(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1497 protected: 1498 void idsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1499 public: 1500 1501 virtual ::std::int32_t sync_ids(); 1502 virtual ::std::int32_t sync_ids(apache::thrift::RpcOptions& rpcOptions); 1503 1504 virtual folly::Future<::std::int32_t> future_ids(); 1505 virtual folly::SemiFuture<::std::int32_t> semifuture_ids(); 1506 virtual folly::Future<::std::int32_t> future_ids(apache::thrift::RpcOptions& rpcOptions); 1507 virtual folly::SemiFuture<::std::int32_t> semifuture_ids(apache::thrift::RpcOptions& rpcOptions); 1508 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_ids(apache::thrift::RpcOptions& rpcOptions); 1509 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_ids(apache::thrift::RpcOptions& rpcOptions); 1510 1511 #if FOLLY_HAS_COROUTINES 1512 template <int = 0> co_ids()1513 folly::coro::Task<::std::int32_t> co_ids() { 1514 return co_ids<false>(nullptr); 1515 } 1516 template <int = 0> co_ids(apache::thrift::RpcOptions & rpcOptions)1517 folly::coro::Task<::std::int32_t> co_ids(apache::thrift::RpcOptions& rpcOptions) { 1518 return co_ids<true>(&rpcOptions); 1519 } 1520 private: 1521 template <bool hasRpcOptions> co_ids(apache::thrift::RpcOptions * rpcOptions)1522 folly::coro::Task<::std::int32_t> co_ids(apache::thrift::RpcOptions* rpcOptions) { 1523 const folly::CancellationToken& cancelToken = 1524 co_await folly::coro::co_current_cancellation_token; 1525 const bool cancellable = cancelToken.canBeCancelled(); 1526 apache::thrift::ClientReceiveState returnState; 1527 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1528 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1529 auto [ctx, header] = idsCtx(rpcOptions); 1530 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1531 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1532 static apache::thrift::RpcOptions defaultRpcOptions; 1533 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1534 if constexpr (hasRpcOptions) { 1535 idsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1536 } else { 1537 idsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1538 } 1539 if (cancellable) { 1540 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1541 co_await callback.co_waitUntilDone(); 1542 } else { 1543 co_await callback.co_waitUntilDone(); 1544 } 1545 if (returnState.isException()) { 1546 co_yield folly::coro::co_error(std::move(returnState.exception())); 1547 } 1548 returnState.resetProtocolId(protocolId); 1549 returnState.resetCtx(std::move(ctx)); 1550 SCOPE_EXIT { 1551 if (hasRpcOptions && returnState.header()) { 1552 auto* rheader = returnState.header(); 1553 if (!rheader->getHeaders().empty()) { 1554 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1555 } 1556 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1557 } 1558 }; 1559 ::std::int32_t _return; 1560 if (auto ew = recv_wrapped_ids(_return, returnState)) { 1561 co_yield folly::coro::co_error(std::move(ew)); 1562 } 1563 co_return _return; 1564 } 1565 public: 1566 #endif // FOLLY_HAS_COROUTINES 1567 1568 virtual void ids(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1569 1570 1571 static folly::exception_wrapper recv_wrapped_ids(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1572 static ::std::int32_t recv_ids(::apache::thrift::ClientReceiveState& state); 1573 // Mock friendly virtual instance method 1574 virtual ::std::int32_t recv_instance_ids(::apache::thrift::ClientReceiveState& state); 1575 virtual folly::exception_wrapper recv_instance_wrapped_ids(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1576 private: 1577 template <typename Protocol_, typename RpcOptions> 1578 void idsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1579 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> idsCtx(apache::thrift::RpcOptions* rpcOptions); 1580 public: 1581 virtual void descriptor(std::unique_ptr<apache::thrift::RequestCallback> callback); 1582 virtual void descriptor(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1583 protected: 1584 void descriptorImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1585 public: 1586 1587 virtual ::std::int32_t sync_descriptor(); 1588 virtual ::std::int32_t sync_descriptor(apache::thrift::RpcOptions& rpcOptions); 1589 1590 virtual folly::Future<::std::int32_t> future_descriptor(); 1591 virtual folly::SemiFuture<::std::int32_t> semifuture_descriptor(); 1592 virtual folly::Future<::std::int32_t> future_descriptor(apache::thrift::RpcOptions& rpcOptions); 1593 virtual folly::SemiFuture<::std::int32_t> semifuture_descriptor(apache::thrift::RpcOptions& rpcOptions); 1594 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_descriptor(apache::thrift::RpcOptions& rpcOptions); 1595 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_descriptor(apache::thrift::RpcOptions& rpcOptions); 1596 1597 #if FOLLY_HAS_COROUTINES 1598 template <int = 0> co_descriptor()1599 folly::coro::Task<::std::int32_t> co_descriptor() { 1600 return co_descriptor<false>(nullptr); 1601 } 1602 template <int = 0> co_descriptor(apache::thrift::RpcOptions & rpcOptions)1603 folly::coro::Task<::std::int32_t> co_descriptor(apache::thrift::RpcOptions& rpcOptions) { 1604 return co_descriptor<true>(&rpcOptions); 1605 } 1606 private: 1607 template <bool hasRpcOptions> co_descriptor(apache::thrift::RpcOptions * rpcOptions)1608 folly::coro::Task<::std::int32_t> co_descriptor(apache::thrift::RpcOptions* rpcOptions) { 1609 const folly::CancellationToken& cancelToken = 1610 co_await folly::coro::co_current_cancellation_token; 1611 const bool cancellable = cancelToken.canBeCancelled(); 1612 apache::thrift::ClientReceiveState returnState; 1613 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1614 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1615 auto [ctx, header] = descriptorCtx(rpcOptions); 1616 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1617 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1618 static apache::thrift::RpcOptions defaultRpcOptions; 1619 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1620 if constexpr (hasRpcOptions) { 1621 descriptorImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1622 } else { 1623 descriptorImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1624 } 1625 if (cancellable) { 1626 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1627 co_await callback.co_waitUntilDone(); 1628 } else { 1629 co_await callback.co_waitUntilDone(); 1630 } 1631 if (returnState.isException()) { 1632 co_yield folly::coro::co_error(std::move(returnState.exception())); 1633 } 1634 returnState.resetProtocolId(protocolId); 1635 returnState.resetCtx(std::move(ctx)); 1636 SCOPE_EXIT { 1637 if (hasRpcOptions && returnState.header()) { 1638 auto* rheader = returnState.header(); 1639 if (!rheader->getHeaders().empty()) { 1640 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1641 } 1642 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1643 } 1644 }; 1645 ::std::int32_t _return; 1646 if (auto ew = recv_wrapped_descriptor(_return, returnState)) { 1647 co_yield folly::coro::co_error(std::move(ew)); 1648 } 1649 co_return _return; 1650 } 1651 public: 1652 #endif // FOLLY_HAS_COROUTINES 1653 1654 virtual void descriptor(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1655 1656 1657 static folly::exception_wrapper recv_wrapped_descriptor(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1658 static ::std::int32_t recv_descriptor(::apache::thrift::ClientReceiveState& state); 1659 // Mock friendly virtual instance method 1660 virtual ::std::int32_t recv_instance_descriptor(::apache::thrift::ClientReceiveState& state); 1661 virtual folly::exception_wrapper recv_instance_wrapped_descriptor(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1662 private: 1663 template <typename Protocol_, typename RpcOptions> 1664 void descriptorT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1665 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> descriptorCtx(apache::thrift::RpcOptions* rpcOptions); 1666 public: 1667 virtual void descriptors(std::unique_ptr<apache::thrift::RequestCallback> callback); 1668 virtual void descriptors(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1669 protected: 1670 void descriptorsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1671 public: 1672 1673 virtual ::std::int32_t sync_descriptors(); 1674 virtual ::std::int32_t sync_descriptors(apache::thrift::RpcOptions& rpcOptions); 1675 1676 virtual folly::Future<::std::int32_t> future_descriptors(); 1677 virtual folly::SemiFuture<::std::int32_t> semifuture_descriptors(); 1678 virtual folly::Future<::std::int32_t> future_descriptors(apache::thrift::RpcOptions& rpcOptions); 1679 virtual folly::SemiFuture<::std::int32_t> semifuture_descriptors(apache::thrift::RpcOptions& rpcOptions); 1680 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_descriptors(apache::thrift::RpcOptions& rpcOptions); 1681 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_descriptors(apache::thrift::RpcOptions& rpcOptions); 1682 1683 #if FOLLY_HAS_COROUTINES 1684 template <int = 0> co_descriptors()1685 folly::coro::Task<::std::int32_t> co_descriptors() { 1686 return co_descriptors<false>(nullptr); 1687 } 1688 template <int = 0> co_descriptors(apache::thrift::RpcOptions & rpcOptions)1689 folly::coro::Task<::std::int32_t> co_descriptors(apache::thrift::RpcOptions& rpcOptions) { 1690 return co_descriptors<true>(&rpcOptions); 1691 } 1692 private: 1693 template <bool hasRpcOptions> co_descriptors(apache::thrift::RpcOptions * rpcOptions)1694 folly::coro::Task<::std::int32_t> co_descriptors(apache::thrift::RpcOptions* rpcOptions) { 1695 const folly::CancellationToken& cancelToken = 1696 co_await folly::coro::co_current_cancellation_token; 1697 const bool cancellable = cancelToken.canBeCancelled(); 1698 apache::thrift::ClientReceiveState returnState; 1699 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1700 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1701 auto [ctx, header] = descriptorsCtx(rpcOptions); 1702 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1703 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1704 static apache::thrift::RpcOptions defaultRpcOptions; 1705 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1706 if constexpr (hasRpcOptions) { 1707 descriptorsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1708 } else { 1709 descriptorsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1710 } 1711 if (cancellable) { 1712 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1713 co_await callback.co_waitUntilDone(); 1714 } else { 1715 co_await callback.co_waitUntilDone(); 1716 } 1717 if (returnState.isException()) { 1718 co_yield folly::coro::co_error(std::move(returnState.exception())); 1719 } 1720 returnState.resetProtocolId(protocolId); 1721 returnState.resetCtx(std::move(ctx)); 1722 SCOPE_EXIT { 1723 if (hasRpcOptions && returnState.header()) { 1724 auto* rheader = returnState.header(); 1725 if (!rheader->getHeaders().empty()) { 1726 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1727 } 1728 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1729 } 1730 }; 1731 ::std::int32_t _return; 1732 if (auto ew = recv_wrapped_descriptors(_return, returnState)) { 1733 co_yield folly::coro::co_error(std::move(ew)); 1734 } 1735 co_return _return; 1736 } 1737 public: 1738 #endif // FOLLY_HAS_COROUTINES 1739 1740 virtual void descriptors(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1741 1742 1743 static folly::exception_wrapper recv_wrapped_descriptors(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1744 static ::std::int32_t recv_descriptors(::apache::thrift::ClientReceiveState& state); 1745 // Mock friendly virtual instance method 1746 virtual ::std::int32_t recv_instance_descriptors(::apache::thrift::ClientReceiveState& state); 1747 virtual folly::exception_wrapper recv_instance_wrapped_descriptors(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1748 private: 1749 template <typename Protocol_, typename RpcOptions> 1750 void descriptorsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1751 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> descriptorsCtx(apache::thrift::RpcOptions* rpcOptions); 1752 public: 1753 virtual void key(std::unique_ptr<apache::thrift::RequestCallback> callback); 1754 virtual void key(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1755 protected: 1756 void keyImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1757 public: 1758 1759 virtual ::std::int32_t sync_key(); 1760 virtual ::std::int32_t sync_key(apache::thrift::RpcOptions& rpcOptions); 1761 1762 virtual folly::Future<::std::int32_t> future_key(); 1763 virtual folly::SemiFuture<::std::int32_t> semifuture_key(); 1764 virtual folly::Future<::std::int32_t> future_key(apache::thrift::RpcOptions& rpcOptions); 1765 virtual folly::SemiFuture<::std::int32_t> semifuture_key(apache::thrift::RpcOptions& rpcOptions); 1766 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_key(apache::thrift::RpcOptions& rpcOptions); 1767 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_key(apache::thrift::RpcOptions& rpcOptions); 1768 1769 #if FOLLY_HAS_COROUTINES 1770 template <int = 0> co_key()1771 folly::coro::Task<::std::int32_t> co_key() { 1772 return co_key<false>(nullptr); 1773 } 1774 template <int = 0> co_key(apache::thrift::RpcOptions & rpcOptions)1775 folly::coro::Task<::std::int32_t> co_key(apache::thrift::RpcOptions& rpcOptions) { 1776 return co_key<true>(&rpcOptions); 1777 } 1778 private: 1779 template <bool hasRpcOptions> co_key(apache::thrift::RpcOptions * rpcOptions)1780 folly::coro::Task<::std::int32_t> co_key(apache::thrift::RpcOptions* rpcOptions) { 1781 const folly::CancellationToken& cancelToken = 1782 co_await folly::coro::co_current_cancellation_token; 1783 const bool cancellable = cancelToken.canBeCancelled(); 1784 apache::thrift::ClientReceiveState returnState; 1785 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1786 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1787 auto [ctx, header] = keyCtx(rpcOptions); 1788 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1789 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1790 static apache::thrift::RpcOptions defaultRpcOptions; 1791 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1792 if constexpr (hasRpcOptions) { 1793 keyImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1794 } else { 1795 keyImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1796 } 1797 if (cancellable) { 1798 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1799 co_await callback.co_waitUntilDone(); 1800 } else { 1801 co_await callback.co_waitUntilDone(); 1802 } 1803 if (returnState.isException()) { 1804 co_yield folly::coro::co_error(std::move(returnState.exception())); 1805 } 1806 returnState.resetProtocolId(protocolId); 1807 returnState.resetCtx(std::move(ctx)); 1808 SCOPE_EXIT { 1809 if (hasRpcOptions && returnState.header()) { 1810 auto* rheader = returnState.header(); 1811 if (!rheader->getHeaders().empty()) { 1812 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1813 } 1814 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1815 } 1816 }; 1817 ::std::int32_t _return; 1818 if (auto ew = recv_wrapped_key(_return, returnState)) { 1819 co_yield folly::coro::co_error(std::move(ew)); 1820 } 1821 co_return _return; 1822 } 1823 public: 1824 #endif // FOLLY_HAS_COROUTINES 1825 1826 virtual void key(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1827 1828 1829 static folly::exception_wrapper recv_wrapped_key(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1830 static ::std::int32_t recv_key(::apache::thrift::ClientReceiveState& state); 1831 // Mock friendly virtual instance method 1832 virtual ::std::int32_t recv_instance_key(::apache::thrift::ClientReceiveState& state); 1833 virtual folly::exception_wrapper recv_instance_wrapped_key(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1834 private: 1835 template <typename Protocol_, typename RpcOptions> 1836 void keyT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1837 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> keyCtx(apache::thrift::RpcOptions* rpcOptions); 1838 public: 1839 virtual void keys(std::unique_ptr<apache::thrift::RequestCallback> callback); 1840 virtual void keys(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1841 protected: 1842 void keysImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1843 public: 1844 1845 virtual ::std::int32_t sync_keys(); 1846 virtual ::std::int32_t sync_keys(apache::thrift::RpcOptions& rpcOptions); 1847 1848 virtual folly::Future<::std::int32_t> future_keys(); 1849 virtual folly::SemiFuture<::std::int32_t> semifuture_keys(); 1850 virtual folly::Future<::std::int32_t> future_keys(apache::thrift::RpcOptions& rpcOptions); 1851 virtual folly::SemiFuture<::std::int32_t> semifuture_keys(apache::thrift::RpcOptions& rpcOptions); 1852 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_keys(apache::thrift::RpcOptions& rpcOptions); 1853 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_keys(apache::thrift::RpcOptions& rpcOptions); 1854 1855 #if FOLLY_HAS_COROUTINES 1856 template <int = 0> co_keys()1857 folly::coro::Task<::std::int32_t> co_keys() { 1858 return co_keys<false>(nullptr); 1859 } 1860 template <int = 0> co_keys(apache::thrift::RpcOptions & rpcOptions)1861 folly::coro::Task<::std::int32_t> co_keys(apache::thrift::RpcOptions& rpcOptions) { 1862 return co_keys<true>(&rpcOptions); 1863 } 1864 private: 1865 template <bool hasRpcOptions> co_keys(apache::thrift::RpcOptions * rpcOptions)1866 folly::coro::Task<::std::int32_t> co_keys(apache::thrift::RpcOptions* rpcOptions) { 1867 const folly::CancellationToken& cancelToken = 1868 co_await folly::coro::co_current_cancellation_token; 1869 const bool cancellable = cancelToken.canBeCancelled(); 1870 apache::thrift::ClientReceiveState returnState; 1871 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1872 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1873 auto [ctx, header] = keysCtx(rpcOptions); 1874 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1875 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1876 static apache::thrift::RpcOptions defaultRpcOptions; 1877 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1878 if constexpr (hasRpcOptions) { 1879 keysImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1880 } else { 1881 keysImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1882 } 1883 if (cancellable) { 1884 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1885 co_await callback.co_waitUntilDone(); 1886 } else { 1887 co_await callback.co_waitUntilDone(); 1888 } 1889 if (returnState.isException()) { 1890 co_yield folly::coro::co_error(std::move(returnState.exception())); 1891 } 1892 returnState.resetProtocolId(protocolId); 1893 returnState.resetCtx(std::move(ctx)); 1894 SCOPE_EXIT { 1895 if (hasRpcOptions && returnState.header()) { 1896 auto* rheader = returnState.header(); 1897 if (!rheader->getHeaders().empty()) { 1898 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1899 } 1900 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1901 } 1902 }; 1903 ::std::int32_t _return; 1904 if (auto ew = recv_wrapped_keys(_return, returnState)) { 1905 co_yield folly::coro::co_error(std::move(ew)); 1906 } 1907 co_return _return; 1908 } 1909 public: 1910 #endif // FOLLY_HAS_COROUTINES 1911 1912 virtual void keys(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1913 1914 1915 static folly::exception_wrapper recv_wrapped_keys(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1916 static ::std::int32_t recv_keys(::apache::thrift::ClientReceiveState& state); 1917 // Mock friendly virtual instance method 1918 virtual ::std::int32_t recv_instance_keys(::apache::thrift::ClientReceiveState& state); 1919 virtual folly::exception_wrapper recv_instance_wrapped_keys(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 1920 private: 1921 template <typename Protocol_, typename RpcOptions> 1922 void keysT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 1923 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> keysCtx(apache::thrift::RpcOptions* rpcOptions); 1924 public: 1925 virtual void annotation(std::unique_ptr<apache::thrift::RequestCallback> callback); 1926 virtual void annotation(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 1927 protected: 1928 void annotationImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 1929 public: 1930 1931 virtual ::std::int32_t sync_annotation(); 1932 virtual ::std::int32_t sync_annotation(apache::thrift::RpcOptions& rpcOptions); 1933 1934 virtual folly::Future<::std::int32_t> future_annotation(); 1935 virtual folly::SemiFuture<::std::int32_t> semifuture_annotation(); 1936 virtual folly::Future<::std::int32_t> future_annotation(apache::thrift::RpcOptions& rpcOptions); 1937 virtual folly::SemiFuture<::std::int32_t> semifuture_annotation(apache::thrift::RpcOptions& rpcOptions); 1938 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_annotation(apache::thrift::RpcOptions& rpcOptions); 1939 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_annotation(apache::thrift::RpcOptions& rpcOptions); 1940 1941 #if FOLLY_HAS_COROUTINES 1942 template <int = 0> co_annotation()1943 folly::coro::Task<::std::int32_t> co_annotation() { 1944 return co_annotation<false>(nullptr); 1945 } 1946 template <int = 0> co_annotation(apache::thrift::RpcOptions & rpcOptions)1947 folly::coro::Task<::std::int32_t> co_annotation(apache::thrift::RpcOptions& rpcOptions) { 1948 return co_annotation<true>(&rpcOptions); 1949 } 1950 private: 1951 template <bool hasRpcOptions> co_annotation(apache::thrift::RpcOptions * rpcOptions)1952 folly::coro::Task<::std::int32_t> co_annotation(apache::thrift::RpcOptions* rpcOptions) { 1953 const folly::CancellationToken& cancelToken = 1954 co_await folly::coro::co_current_cancellation_token; 1955 const bool cancellable = cancelToken.canBeCancelled(); 1956 apache::thrift::ClientReceiveState returnState; 1957 apache::thrift::ClientSyncCallback<false> callback(&returnState); 1958 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 1959 auto [ctx, header] = annotationCtx(rpcOptions); 1960 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 1961 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 1962 static apache::thrift::RpcOptions defaultRpcOptions; 1963 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 1964 if constexpr (hasRpcOptions) { 1965 annotationImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1966 } else { 1967 annotationImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 1968 } 1969 if (cancellable) { 1970 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 1971 co_await callback.co_waitUntilDone(); 1972 } else { 1973 co_await callback.co_waitUntilDone(); 1974 } 1975 if (returnState.isException()) { 1976 co_yield folly::coro::co_error(std::move(returnState.exception())); 1977 } 1978 returnState.resetProtocolId(protocolId); 1979 returnState.resetCtx(std::move(ctx)); 1980 SCOPE_EXIT { 1981 if (hasRpcOptions && returnState.header()) { 1982 auto* rheader = returnState.header(); 1983 if (!rheader->getHeaders().empty()) { 1984 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 1985 } 1986 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 1987 } 1988 }; 1989 ::std::int32_t _return; 1990 if (auto ew = recv_wrapped_annotation(_return, returnState)) { 1991 co_yield folly::coro::co_error(std::move(ew)); 1992 } 1993 co_return _return; 1994 } 1995 public: 1996 #endif // FOLLY_HAS_COROUTINES 1997 1998 virtual void annotation(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 1999 2000 2001 static folly::exception_wrapper recv_wrapped_annotation(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2002 static ::std::int32_t recv_annotation(::apache::thrift::ClientReceiveState& state); 2003 // Mock friendly virtual instance method 2004 virtual ::std::int32_t recv_instance_annotation(::apache::thrift::ClientReceiveState& state); 2005 virtual folly::exception_wrapper recv_instance_wrapped_annotation(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2006 private: 2007 template <typename Protocol_, typename RpcOptions> 2008 void annotationT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 2009 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> annotationCtx(apache::thrift::RpcOptions* rpcOptions); 2010 public: 2011 virtual void annotations(std::unique_ptr<apache::thrift::RequestCallback> callback); 2012 virtual void annotations(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 2013 protected: 2014 void annotationsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 2015 public: 2016 2017 virtual ::std::int32_t sync_annotations(); 2018 virtual ::std::int32_t sync_annotations(apache::thrift::RpcOptions& rpcOptions); 2019 2020 virtual folly::Future<::std::int32_t> future_annotations(); 2021 virtual folly::SemiFuture<::std::int32_t> semifuture_annotations(); 2022 virtual folly::Future<::std::int32_t> future_annotations(apache::thrift::RpcOptions& rpcOptions); 2023 virtual folly::SemiFuture<::std::int32_t> semifuture_annotations(apache::thrift::RpcOptions& rpcOptions); 2024 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_annotations(apache::thrift::RpcOptions& rpcOptions); 2025 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_annotations(apache::thrift::RpcOptions& rpcOptions); 2026 2027 #if FOLLY_HAS_COROUTINES 2028 template <int = 0> co_annotations()2029 folly::coro::Task<::std::int32_t> co_annotations() { 2030 return co_annotations<false>(nullptr); 2031 } 2032 template <int = 0> co_annotations(apache::thrift::RpcOptions & rpcOptions)2033 folly::coro::Task<::std::int32_t> co_annotations(apache::thrift::RpcOptions& rpcOptions) { 2034 return co_annotations<true>(&rpcOptions); 2035 } 2036 private: 2037 template <bool hasRpcOptions> co_annotations(apache::thrift::RpcOptions * rpcOptions)2038 folly::coro::Task<::std::int32_t> co_annotations(apache::thrift::RpcOptions* rpcOptions) { 2039 const folly::CancellationToken& cancelToken = 2040 co_await folly::coro::co_current_cancellation_token; 2041 const bool cancellable = cancelToken.canBeCancelled(); 2042 apache::thrift::ClientReceiveState returnState; 2043 apache::thrift::ClientSyncCallback<false> callback(&returnState); 2044 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 2045 auto [ctx, header] = annotationsCtx(rpcOptions); 2046 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 2047 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 2048 static apache::thrift::RpcOptions defaultRpcOptions; 2049 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 2050 if constexpr (hasRpcOptions) { 2051 annotationsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2052 } else { 2053 annotationsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2054 } 2055 if (cancellable) { 2056 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 2057 co_await callback.co_waitUntilDone(); 2058 } else { 2059 co_await callback.co_waitUntilDone(); 2060 } 2061 if (returnState.isException()) { 2062 co_yield folly::coro::co_error(std::move(returnState.exception())); 2063 } 2064 returnState.resetProtocolId(protocolId); 2065 returnState.resetCtx(std::move(ctx)); 2066 SCOPE_EXIT { 2067 if (hasRpcOptions && returnState.header()) { 2068 auto* rheader = returnState.header(); 2069 if (!rheader->getHeaders().empty()) { 2070 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 2071 } 2072 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 2073 } 2074 }; 2075 ::std::int32_t _return; 2076 if (auto ew = recv_wrapped_annotations(_return, returnState)) { 2077 co_yield folly::coro::co_error(std::move(ew)); 2078 } 2079 co_return _return; 2080 } 2081 public: 2082 #endif // FOLLY_HAS_COROUTINES 2083 2084 virtual void annotations(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 2085 2086 2087 static folly::exception_wrapper recv_wrapped_annotations(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2088 static ::std::int32_t recv_annotations(::apache::thrift::ClientReceiveState& state); 2089 // Mock friendly virtual instance method 2090 virtual ::std::int32_t recv_instance_annotations(::apache::thrift::ClientReceiveState& state); 2091 virtual folly::exception_wrapper recv_instance_wrapped_annotations(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2092 private: 2093 template <typename Protocol_, typename RpcOptions> 2094 void annotationsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 2095 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> annotationsCtx(apache::thrift::RpcOptions* rpcOptions); 2096 public: 2097 virtual void member(std::unique_ptr<apache::thrift::RequestCallback> callback); 2098 virtual void member(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 2099 protected: 2100 void memberImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 2101 public: 2102 2103 virtual ::std::int32_t sync_member(); 2104 virtual ::std::int32_t sync_member(apache::thrift::RpcOptions& rpcOptions); 2105 2106 virtual folly::Future<::std::int32_t> future_member(); 2107 virtual folly::SemiFuture<::std::int32_t> semifuture_member(); 2108 virtual folly::Future<::std::int32_t> future_member(apache::thrift::RpcOptions& rpcOptions); 2109 virtual folly::SemiFuture<::std::int32_t> semifuture_member(apache::thrift::RpcOptions& rpcOptions); 2110 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_member(apache::thrift::RpcOptions& rpcOptions); 2111 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_member(apache::thrift::RpcOptions& rpcOptions); 2112 2113 #if FOLLY_HAS_COROUTINES 2114 template <int = 0> co_member()2115 folly::coro::Task<::std::int32_t> co_member() { 2116 return co_member<false>(nullptr); 2117 } 2118 template <int = 0> co_member(apache::thrift::RpcOptions & rpcOptions)2119 folly::coro::Task<::std::int32_t> co_member(apache::thrift::RpcOptions& rpcOptions) { 2120 return co_member<true>(&rpcOptions); 2121 } 2122 private: 2123 template <bool hasRpcOptions> co_member(apache::thrift::RpcOptions * rpcOptions)2124 folly::coro::Task<::std::int32_t> co_member(apache::thrift::RpcOptions* rpcOptions) { 2125 const folly::CancellationToken& cancelToken = 2126 co_await folly::coro::co_current_cancellation_token; 2127 const bool cancellable = cancelToken.canBeCancelled(); 2128 apache::thrift::ClientReceiveState returnState; 2129 apache::thrift::ClientSyncCallback<false> callback(&returnState); 2130 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 2131 auto [ctx, header] = memberCtx(rpcOptions); 2132 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 2133 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 2134 static apache::thrift::RpcOptions defaultRpcOptions; 2135 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 2136 if constexpr (hasRpcOptions) { 2137 memberImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2138 } else { 2139 memberImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2140 } 2141 if (cancellable) { 2142 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 2143 co_await callback.co_waitUntilDone(); 2144 } else { 2145 co_await callback.co_waitUntilDone(); 2146 } 2147 if (returnState.isException()) { 2148 co_yield folly::coro::co_error(std::move(returnState.exception())); 2149 } 2150 returnState.resetProtocolId(protocolId); 2151 returnState.resetCtx(std::move(ctx)); 2152 SCOPE_EXIT { 2153 if (hasRpcOptions && returnState.header()) { 2154 auto* rheader = returnState.header(); 2155 if (!rheader->getHeaders().empty()) { 2156 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 2157 } 2158 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 2159 } 2160 }; 2161 ::std::int32_t _return; 2162 if (auto ew = recv_wrapped_member(_return, returnState)) { 2163 co_yield folly::coro::co_error(std::move(ew)); 2164 } 2165 co_return _return; 2166 } 2167 public: 2168 #endif // FOLLY_HAS_COROUTINES 2169 2170 virtual void member(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 2171 2172 2173 static folly::exception_wrapper recv_wrapped_member(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2174 static ::std::int32_t recv_member(::apache::thrift::ClientReceiveState& state); 2175 // Mock friendly virtual instance method 2176 virtual ::std::int32_t recv_instance_member(::apache::thrift::ClientReceiveState& state); 2177 virtual folly::exception_wrapper recv_instance_wrapped_member(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2178 private: 2179 template <typename Protocol_, typename RpcOptions> 2180 void memberT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 2181 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> memberCtx(apache::thrift::RpcOptions* rpcOptions); 2182 public: 2183 virtual void members(std::unique_ptr<apache::thrift::RequestCallback> callback); 2184 virtual void members(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 2185 protected: 2186 void membersImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 2187 public: 2188 2189 virtual ::std::int32_t sync_members(); 2190 virtual ::std::int32_t sync_members(apache::thrift::RpcOptions& rpcOptions); 2191 2192 virtual folly::Future<::std::int32_t> future_members(); 2193 virtual folly::SemiFuture<::std::int32_t> semifuture_members(); 2194 virtual folly::Future<::std::int32_t> future_members(apache::thrift::RpcOptions& rpcOptions); 2195 virtual folly::SemiFuture<::std::int32_t> semifuture_members(apache::thrift::RpcOptions& rpcOptions); 2196 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_members(apache::thrift::RpcOptions& rpcOptions); 2197 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_members(apache::thrift::RpcOptions& rpcOptions); 2198 2199 #if FOLLY_HAS_COROUTINES 2200 template <int = 0> co_members()2201 folly::coro::Task<::std::int32_t> co_members() { 2202 return co_members<false>(nullptr); 2203 } 2204 template <int = 0> co_members(apache::thrift::RpcOptions & rpcOptions)2205 folly::coro::Task<::std::int32_t> co_members(apache::thrift::RpcOptions& rpcOptions) { 2206 return co_members<true>(&rpcOptions); 2207 } 2208 private: 2209 template <bool hasRpcOptions> co_members(apache::thrift::RpcOptions * rpcOptions)2210 folly::coro::Task<::std::int32_t> co_members(apache::thrift::RpcOptions* rpcOptions) { 2211 const folly::CancellationToken& cancelToken = 2212 co_await folly::coro::co_current_cancellation_token; 2213 const bool cancellable = cancelToken.canBeCancelled(); 2214 apache::thrift::ClientReceiveState returnState; 2215 apache::thrift::ClientSyncCallback<false> callback(&returnState); 2216 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 2217 auto [ctx, header] = membersCtx(rpcOptions); 2218 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 2219 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 2220 static apache::thrift::RpcOptions defaultRpcOptions; 2221 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 2222 if constexpr (hasRpcOptions) { 2223 membersImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2224 } else { 2225 membersImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2226 } 2227 if (cancellable) { 2228 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 2229 co_await callback.co_waitUntilDone(); 2230 } else { 2231 co_await callback.co_waitUntilDone(); 2232 } 2233 if (returnState.isException()) { 2234 co_yield folly::coro::co_error(std::move(returnState.exception())); 2235 } 2236 returnState.resetProtocolId(protocolId); 2237 returnState.resetCtx(std::move(ctx)); 2238 SCOPE_EXIT { 2239 if (hasRpcOptions && returnState.header()) { 2240 auto* rheader = returnState.header(); 2241 if (!rheader->getHeaders().empty()) { 2242 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 2243 } 2244 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 2245 } 2246 }; 2247 ::std::int32_t _return; 2248 if (auto ew = recv_wrapped_members(_return, returnState)) { 2249 co_yield folly::coro::co_error(std::move(ew)); 2250 } 2251 co_return _return; 2252 } 2253 public: 2254 #endif // FOLLY_HAS_COROUTINES 2255 2256 virtual void members(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 2257 2258 2259 static folly::exception_wrapper recv_wrapped_members(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2260 static ::std::int32_t recv_members(::apache::thrift::ClientReceiveState& state); 2261 // Mock friendly virtual instance method 2262 virtual ::std::int32_t recv_instance_members(::apache::thrift::ClientReceiveState& state); 2263 virtual folly::exception_wrapper recv_instance_wrapped_members(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2264 private: 2265 template <typename Protocol_, typename RpcOptions> 2266 void membersT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 2267 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> membersCtx(apache::thrift::RpcOptions* rpcOptions); 2268 public: 2269 virtual void field(std::unique_ptr<apache::thrift::RequestCallback> callback); 2270 virtual void field(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 2271 protected: 2272 void fieldImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 2273 public: 2274 2275 virtual ::std::int32_t sync_field(); 2276 virtual ::std::int32_t sync_field(apache::thrift::RpcOptions& rpcOptions); 2277 2278 virtual folly::Future<::std::int32_t> future_field(); 2279 virtual folly::SemiFuture<::std::int32_t> semifuture_field(); 2280 virtual folly::Future<::std::int32_t> future_field(apache::thrift::RpcOptions& rpcOptions); 2281 virtual folly::SemiFuture<::std::int32_t> semifuture_field(apache::thrift::RpcOptions& rpcOptions); 2282 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_field(apache::thrift::RpcOptions& rpcOptions); 2283 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_field(apache::thrift::RpcOptions& rpcOptions); 2284 2285 #if FOLLY_HAS_COROUTINES 2286 template <int = 0> co_field()2287 folly::coro::Task<::std::int32_t> co_field() { 2288 return co_field<false>(nullptr); 2289 } 2290 template <int = 0> co_field(apache::thrift::RpcOptions & rpcOptions)2291 folly::coro::Task<::std::int32_t> co_field(apache::thrift::RpcOptions& rpcOptions) { 2292 return co_field<true>(&rpcOptions); 2293 } 2294 private: 2295 template <bool hasRpcOptions> co_field(apache::thrift::RpcOptions * rpcOptions)2296 folly::coro::Task<::std::int32_t> co_field(apache::thrift::RpcOptions* rpcOptions) { 2297 const folly::CancellationToken& cancelToken = 2298 co_await folly::coro::co_current_cancellation_token; 2299 const bool cancellable = cancelToken.canBeCancelled(); 2300 apache::thrift::ClientReceiveState returnState; 2301 apache::thrift::ClientSyncCallback<false> callback(&returnState); 2302 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 2303 auto [ctx, header] = fieldCtx(rpcOptions); 2304 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 2305 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 2306 static apache::thrift::RpcOptions defaultRpcOptions; 2307 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 2308 if constexpr (hasRpcOptions) { 2309 fieldImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2310 } else { 2311 fieldImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2312 } 2313 if (cancellable) { 2314 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 2315 co_await callback.co_waitUntilDone(); 2316 } else { 2317 co_await callback.co_waitUntilDone(); 2318 } 2319 if (returnState.isException()) { 2320 co_yield folly::coro::co_error(std::move(returnState.exception())); 2321 } 2322 returnState.resetProtocolId(protocolId); 2323 returnState.resetCtx(std::move(ctx)); 2324 SCOPE_EXIT { 2325 if (hasRpcOptions && returnState.header()) { 2326 auto* rheader = returnState.header(); 2327 if (!rheader->getHeaders().empty()) { 2328 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 2329 } 2330 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 2331 } 2332 }; 2333 ::std::int32_t _return; 2334 if (auto ew = recv_wrapped_field(_return, returnState)) { 2335 co_yield folly::coro::co_error(std::move(ew)); 2336 } 2337 co_return _return; 2338 } 2339 public: 2340 #endif // FOLLY_HAS_COROUTINES 2341 2342 virtual void field(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 2343 2344 2345 static folly::exception_wrapper recv_wrapped_field(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2346 static ::std::int32_t recv_field(::apache::thrift::ClientReceiveState& state); 2347 // Mock friendly virtual instance method 2348 virtual ::std::int32_t recv_instance_field(::apache::thrift::ClientReceiveState& state); 2349 virtual folly::exception_wrapper recv_instance_wrapped_field(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2350 private: 2351 template <typename Protocol_, typename RpcOptions> 2352 void fieldT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 2353 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> fieldCtx(apache::thrift::RpcOptions* rpcOptions); 2354 public: 2355 virtual void fields(std::unique_ptr<apache::thrift::RequestCallback> callback); 2356 virtual void fields(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback); 2357 protected: 2358 void fieldsImpl(apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, bool stealRpcOptions = false); 2359 public: 2360 2361 virtual ::std::int32_t sync_fields(); 2362 virtual ::std::int32_t sync_fields(apache::thrift::RpcOptions& rpcOptions); 2363 2364 virtual folly::Future<::std::int32_t> future_fields(); 2365 virtual folly::SemiFuture<::std::int32_t> semifuture_fields(); 2366 virtual folly::Future<::std::int32_t> future_fields(apache::thrift::RpcOptions& rpcOptions); 2367 virtual folly::SemiFuture<::std::int32_t> semifuture_fields(apache::thrift::RpcOptions& rpcOptions); 2368 virtual folly::Future<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_future_fields(apache::thrift::RpcOptions& rpcOptions); 2369 virtual folly::SemiFuture<std::pair<::std::int32_t, std::unique_ptr<apache::thrift::transport::THeader>>> header_semifuture_fields(apache::thrift::RpcOptions& rpcOptions); 2370 2371 #if FOLLY_HAS_COROUTINES 2372 template <int = 0> co_fields()2373 folly::coro::Task<::std::int32_t> co_fields() { 2374 return co_fields<false>(nullptr); 2375 } 2376 template <int = 0> co_fields(apache::thrift::RpcOptions & rpcOptions)2377 folly::coro::Task<::std::int32_t> co_fields(apache::thrift::RpcOptions& rpcOptions) { 2378 return co_fields<true>(&rpcOptions); 2379 } 2380 private: 2381 template <bool hasRpcOptions> co_fields(apache::thrift::RpcOptions * rpcOptions)2382 folly::coro::Task<::std::int32_t> co_fields(apache::thrift::RpcOptions* rpcOptions) { 2383 const folly::CancellationToken& cancelToken = 2384 co_await folly::coro::co_current_cancellation_token; 2385 const bool cancellable = cancelToken.canBeCancelled(); 2386 apache::thrift::ClientReceiveState returnState; 2387 apache::thrift::ClientSyncCallback<false> callback(&returnState); 2388 auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); 2389 auto [ctx, header] = fieldsCtx(rpcOptions); 2390 using CancellableCallback = apache::thrift::CancellableRequestClientCallback<false>; 2391 auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; 2392 static apache::thrift::RpcOptions defaultRpcOptions; 2393 auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); 2394 if constexpr (hasRpcOptions) { 2395 fieldsImpl(*rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2396 } else { 2397 fieldsImpl(defaultRpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback)); 2398 } 2399 if (cancellable) { 2400 folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); 2401 co_await callback.co_waitUntilDone(); 2402 } else { 2403 co_await callback.co_waitUntilDone(); 2404 } 2405 if (returnState.isException()) { 2406 co_yield folly::coro::co_error(std::move(returnState.exception())); 2407 } 2408 returnState.resetProtocolId(protocolId); 2409 returnState.resetCtx(std::move(ctx)); 2410 SCOPE_EXIT { 2411 if (hasRpcOptions && returnState.header()) { 2412 auto* rheader = returnState.header(); 2413 if (!rheader->getHeaders().empty()) { 2414 rpcOptions->setReadHeaders(rheader->releaseHeaders()); 2415 } 2416 rpcOptions->setRoutingData(rheader->releaseRoutingData()); 2417 } 2418 }; 2419 ::std::int32_t _return; 2420 if (auto ew = recv_wrapped_fields(_return, returnState)) { 2421 co_yield folly::coro::co_error(std::move(ew)); 2422 } 2423 co_return _return; 2424 } 2425 public: 2426 #endif // FOLLY_HAS_COROUTINES 2427 2428 virtual void fields(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback); 2429 2430 2431 static folly::exception_wrapper recv_wrapped_fields(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2432 static ::std::int32_t recv_fields(::apache::thrift::ClientReceiveState& state); 2433 // Mock friendly virtual instance method 2434 virtual ::std::int32_t recv_instance_fields(::apache::thrift::ClientReceiveState& state); 2435 virtual folly::exception_wrapper recv_instance_wrapped_fields(::std::int32_t& _return, ::apache::thrift::ClientReceiveState& state); 2436 private: 2437 template <typename Protocol_, typename RpcOptions> 2438 void fieldsT(Protocol_* prot, RpcOptions&& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback); 2439 std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> fieldsCtx(apache::thrift::RpcOptions* rpcOptions); 2440 public: 2441 }; 2442 2443 }} // test_cpp2::cpp_reflection 2444