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