xdrpp
RFC4506 XDR compiler and message library
rpcb_prot.hh
1 // -*- C++ -*-
2 // Automatically generated from xdrpp/rpcb_prot.x.
3 // DO NOT EDIT or your changes may be overwritten
4 
5 #ifndef __XDR_XDRPP_RPCB_PROT_HH_INCLUDED__
6 #define __XDR_XDRPP_RPCB_PROT_HH_INCLUDED__ 1
7 
8 #include <xdrpp/types.h>
9 
10 namespace xdr {
11 
12 Constexpr const std::uint32_t RPCB_PORT = 111;
13 
14 struct rpcb {
15  std::uint32_t r_prog{};
16  std::uint32_t r_vers{};
17  xdr::xstring<> r_netid{};
18  xdr::xstring<> r_addr{};
19  xdr::xstring<> r_owner{};
20 
21  rpcb() = default;
22  template<typename _r_prog_T,
23  typename _r_vers_T,
24  typename _r_netid_T,
25  typename _r_addr_T,
26  typename _r_owner_T,
27  typename = typename
28  std::enable_if<std::is_constructible<std::uint32_t, _r_prog_T>::value
29  && std::is_constructible<std::uint32_t, _r_vers_T>::value
30  && std::is_constructible<xdr::xstring<>, _r_netid_T>::value
31  && std::is_constructible<xdr::xstring<>, _r_addr_T>::value
32  && std::is_constructible<xdr::xstring<>, _r_owner_T>::value
33  >::type>
34  explicit rpcb(_r_prog_T &&_r_prog,
35  _r_vers_T &&_r_vers,
36  _r_netid_T &&_r_netid,
37  _r_addr_T &&_r_addr,
38  _r_owner_T &&_r_owner)
39  : r_prog(std::forward<_r_prog_T>(_r_prog)),
40  r_vers(std::forward<_r_vers_T>(_r_vers)),
41  r_netid(std::forward<_r_netid_T>(_r_netid)),
42  r_addr(std::forward<_r_addr_T>(_r_addr)),
43  r_owner(std::forward<_r_owner_T>(_r_owner)) {}
44 };
45 } namespace xdr {
46 template<> struct xdr_traits<::xdr::rpcb>
47  : xdr_struct_base<field_ptr<::xdr::rpcb,
48  decltype(::xdr::rpcb::r_prog),
49  &::xdr::rpcb::r_prog>,
50  field_ptr<::xdr::rpcb,
51  decltype(::xdr::rpcb::r_vers),
52  &::xdr::rpcb::r_vers>,
53  field_ptr<::xdr::rpcb,
54  decltype(::xdr::rpcb::r_netid),
55  &::xdr::rpcb::r_netid>,
56  field_ptr<::xdr::rpcb,
57  decltype(::xdr::rpcb::r_addr),
58  &::xdr::rpcb::r_addr>,
59  field_ptr<::xdr::rpcb,
60  decltype(::xdr::rpcb::r_owner),
61  &::xdr::rpcb::r_owner>> {
62  template<typename Archive> static void
63  save(Archive &ar, const ::xdr::rpcb &obj) {
64  archive(ar, obj.r_prog, "r_prog");
65  archive(ar, obj.r_vers, "r_vers");
66  archive(ar, obj.r_netid, "r_netid");
67  archive(ar, obj.r_addr, "r_addr");
68  archive(ar, obj.r_owner, "r_owner");
69  }
70  template<typename Archive> static void
71  load(Archive &ar, ::xdr::rpcb &obj) {
72  archive(ar, obj.r_prog, "r_prog");
73  archive(ar, obj.r_vers, "r_vers");
74  archive(ar, obj.r_netid, "r_netid");
75  archive(ar, obj.r_addr, "r_addr");
76  archive(ar, obj.r_owner, "r_owner");
77  xdr::validate(obj);
78  }
79 };
80 } namespace xdr {
81 
82 struct rp__list {
83  rpcb rpcb_map{};
84  xdr::pointer<rp__list> rpcb_next{};
85 
86  rp__list() = default;
87  template<typename _rpcb_map_T,
88  typename _rpcb_next_T,
89  typename = typename
90  std::enable_if<std::is_constructible<rpcb, _rpcb_map_T>::value
91  && std::is_constructible<xdr::pointer<rp__list>, _rpcb_next_T>::value
92  >::type>
93  explicit rp__list(_rpcb_map_T &&_rpcb_map,
94  _rpcb_next_T &&_rpcb_next)
95  : rpcb_map(std::forward<_rpcb_map_T>(_rpcb_map)),
96  rpcb_next(std::forward<_rpcb_next_T>(_rpcb_next)) {}
97 };
98 } namespace xdr {
99 template<> struct xdr_traits<::xdr::rp__list>
100  : xdr_struct_base<field_ptr<::xdr::rp__list,
101  decltype(::xdr::rp__list::rpcb_map),
102  &::xdr::rp__list::rpcb_map>,
103  field_ptr<::xdr::rp__list,
104  decltype(::xdr::rp__list::rpcb_next),
105  &::xdr::rp__list::rpcb_next>> {
106  template<typename Archive> static void
107  save(Archive &ar, const ::xdr::rp__list &obj) {
108  archive(ar, obj.rpcb_map, "rpcb_map");
109  archive(ar, obj.rpcb_next, "rpcb_next");
110  }
111  template<typename Archive> static void
112  load(Archive &ar, ::xdr::rp__list &obj) {
113  archive(ar, obj.rpcb_map, "rpcb_map");
114  archive(ar, obj.rpcb_next, "rpcb_next");
115  xdr::validate(obj);
116  }
117 };
118 } namespace xdr {
119 
120 using rpcblist_ptr = xdr::pointer<rp__list>;
121 
122 struct rpcb_rmtcallargs {
123  std::uint32_t prog{};
124  std::uint32_t vers{};
125  std::uint32_t proc{};
126  xdr::opaque_vec<> args{};
127 
128  rpcb_rmtcallargs() = default;
129  template<typename _prog_T,
130  typename _vers_T,
131  typename _proc_T,
132  typename _args_T,
133  typename = typename
134  std::enable_if<std::is_constructible<std::uint32_t, _prog_T>::value
135  && std::is_constructible<std::uint32_t, _vers_T>::value
136  && std::is_constructible<std::uint32_t, _proc_T>::value
137  && std::is_constructible<xdr::opaque_vec<>, _args_T>::value
138  >::type>
139  explicit rpcb_rmtcallargs(_prog_T &&_prog,
140  _vers_T &&_vers,
141  _proc_T &&_proc,
142  _args_T &&_args)
143  : prog(std::forward<_prog_T>(_prog)),
144  vers(std::forward<_vers_T>(_vers)),
145  proc(std::forward<_proc_T>(_proc)),
146  args(std::forward<_args_T>(_args)) {}
147 };
148 } namespace xdr {
149 template<> struct xdr_traits<::xdr::rpcb_rmtcallargs>
150  : xdr_struct_base<field_ptr<::xdr::rpcb_rmtcallargs,
151  decltype(::xdr::rpcb_rmtcallargs::prog),
152  &::xdr::rpcb_rmtcallargs::prog>,
153  field_ptr<::xdr::rpcb_rmtcallargs,
154  decltype(::xdr::rpcb_rmtcallargs::vers),
155  &::xdr::rpcb_rmtcallargs::vers>,
156  field_ptr<::xdr::rpcb_rmtcallargs,
157  decltype(::xdr::rpcb_rmtcallargs::proc),
158  &::xdr::rpcb_rmtcallargs::proc>,
159  field_ptr<::xdr::rpcb_rmtcallargs,
160  decltype(::xdr::rpcb_rmtcallargs::args),
161  &::xdr::rpcb_rmtcallargs::args>> {
162  template<typename Archive> static void
163  save(Archive &ar, const ::xdr::rpcb_rmtcallargs &obj) {
164  archive(ar, obj.prog, "prog");
165  archive(ar, obj.vers, "vers");
166  archive(ar, obj.proc, "proc");
167  archive(ar, obj.args, "args");
168  }
169  template<typename Archive> static void
170  load(Archive &ar, ::xdr::rpcb_rmtcallargs &obj) {
171  archive(ar, obj.prog, "prog");
172  archive(ar, obj.vers, "vers");
173  archive(ar, obj.proc, "proc");
174  archive(ar, obj.args, "args");
175  xdr::validate(obj);
176  }
177 };
178 } namespace xdr {
179 
180 struct rpcb_rmtcallres {
181  xdr::xstring<> addr{};
182  xdr::opaque_vec<> results{};
183 
184  rpcb_rmtcallres() = default;
185  template<typename _addr_T,
186  typename _results_T,
187  typename = typename
188  std::enable_if<std::is_constructible<xdr::xstring<>, _addr_T>::value
189  && std::is_constructible<xdr::opaque_vec<>, _results_T>::value
190  >::type>
191  explicit rpcb_rmtcallres(_addr_T &&_addr,
192  _results_T &&_results)
193  : addr(std::forward<_addr_T>(_addr)),
194  results(std::forward<_results_T>(_results)) {}
195 };
196 } namespace xdr {
197 template<> struct xdr_traits<::xdr::rpcb_rmtcallres>
198  : xdr_struct_base<field_ptr<::xdr::rpcb_rmtcallres,
199  decltype(::xdr::rpcb_rmtcallres::addr),
200  &::xdr::rpcb_rmtcallres::addr>,
201  field_ptr<::xdr::rpcb_rmtcallres,
202  decltype(::xdr::rpcb_rmtcallres::results),
203  &::xdr::rpcb_rmtcallres::results>> {
204  template<typename Archive> static void
205  save(Archive &ar, const ::xdr::rpcb_rmtcallres &obj) {
206  archive(ar, obj.addr, "addr");
207  archive(ar, obj.results, "results");
208  }
209  template<typename Archive> static void
210  load(Archive &ar, ::xdr::rpcb_rmtcallres &obj) {
211  archive(ar, obj.addr, "addr");
212  archive(ar, obj.results, "results");
213  xdr::validate(obj);
214  }
215 };
216 } namespace xdr {
217 
218 struct rpcb_entry {
219  xdr::xstring<> r_maddr{};
220  xdr::xstring<> r_nc_netid{};
221  std::uint32_t r_nc_semantics{};
222  xdr::xstring<> r_nc_protofmly{};
223  xdr::xstring<> r_nc_proto{};
224 
225  rpcb_entry() = default;
226  template<typename _r_maddr_T,
227  typename _r_nc_netid_T,
228  typename _r_nc_semantics_T,
229  typename _r_nc_protofmly_T,
230  typename _r_nc_proto_T,
231  typename = typename
232  std::enable_if<std::is_constructible<xdr::xstring<>, _r_maddr_T>::value
233  && std::is_constructible<xdr::xstring<>, _r_nc_netid_T>::value
234  && std::is_constructible<std::uint32_t, _r_nc_semantics_T>::value
235  && std::is_constructible<xdr::xstring<>, _r_nc_protofmly_T>::value
236  && std::is_constructible<xdr::xstring<>, _r_nc_proto_T>::value
237  >::type>
238  explicit rpcb_entry(_r_maddr_T &&_r_maddr,
239  _r_nc_netid_T &&_r_nc_netid,
240  _r_nc_semantics_T &&_r_nc_semantics,
241  _r_nc_protofmly_T &&_r_nc_protofmly,
242  _r_nc_proto_T &&_r_nc_proto)
243  : r_maddr(std::forward<_r_maddr_T>(_r_maddr)),
244  r_nc_netid(std::forward<_r_nc_netid_T>(_r_nc_netid)),
245  r_nc_semantics(std::forward<_r_nc_semantics_T>(_r_nc_semantics)),
246  r_nc_protofmly(std::forward<_r_nc_protofmly_T>(_r_nc_protofmly)),
247  r_nc_proto(std::forward<_r_nc_proto_T>(_r_nc_proto)) {}
248 };
249 } namespace xdr {
250 template<> struct xdr_traits<::xdr::rpcb_entry>
251  : xdr_struct_base<field_ptr<::xdr::rpcb_entry,
252  decltype(::xdr::rpcb_entry::r_maddr),
253  &::xdr::rpcb_entry::r_maddr>,
254  field_ptr<::xdr::rpcb_entry,
255  decltype(::xdr::rpcb_entry::r_nc_netid),
256  &::xdr::rpcb_entry::r_nc_netid>,
257  field_ptr<::xdr::rpcb_entry,
258  decltype(::xdr::rpcb_entry::r_nc_semantics),
259  &::xdr::rpcb_entry::r_nc_semantics>,
260  field_ptr<::xdr::rpcb_entry,
261  decltype(::xdr::rpcb_entry::r_nc_protofmly),
262  &::xdr::rpcb_entry::r_nc_protofmly>,
263  field_ptr<::xdr::rpcb_entry,
264  decltype(::xdr::rpcb_entry::r_nc_proto),
265  &::xdr::rpcb_entry::r_nc_proto>> {
266  template<typename Archive> static void
267  save(Archive &ar, const ::xdr::rpcb_entry &obj) {
268  archive(ar, obj.r_maddr, "r_maddr");
269  archive(ar, obj.r_nc_netid, "r_nc_netid");
270  archive(ar, obj.r_nc_semantics, "r_nc_semantics");
271  archive(ar, obj.r_nc_protofmly, "r_nc_protofmly");
272  archive(ar, obj.r_nc_proto, "r_nc_proto");
273  }
274  template<typename Archive> static void
275  load(Archive &ar, ::xdr::rpcb_entry &obj) {
276  archive(ar, obj.r_maddr, "r_maddr");
277  archive(ar, obj.r_nc_netid, "r_nc_netid");
278  archive(ar, obj.r_nc_semantics, "r_nc_semantics");
279  archive(ar, obj.r_nc_protofmly, "r_nc_protofmly");
280  archive(ar, obj.r_nc_proto, "r_nc_proto");
281  xdr::validate(obj);
282  }
283 };
284 } namespace xdr {
285 
286 struct rpcb_entry_list {
287  rpcb_entry rpcb_entry_map{};
288  xdr::pointer<rpcb_entry_list> rpcb_entry_next{};
289 
290  rpcb_entry_list() = default;
291  template<typename _rpcb_entry_map_T,
292  typename _rpcb_entry_next_T,
293  typename = typename
294  std::enable_if<std::is_constructible<rpcb_entry, _rpcb_entry_map_T>::value
295  && std::is_constructible<xdr::pointer<rpcb_entry_list>, _rpcb_entry_next_T>::value
296  >::type>
297  explicit rpcb_entry_list(_rpcb_entry_map_T &&_rpcb_entry_map,
298  _rpcb_entry_next_T &&_rpcb_entry_next)
299  : rpcb_entry_map(std::forward<_rpcb_entry_map_T>(_rpcb_entry_map)),
300  rpcb_entry_next(std::forward<_rpcb_entry_next_T>(_rpcb_entry_next)) {}
301 };
302 } namespace xdr {
303 template<> struct xdr_traits<::xdr::rpcb_entry_list>
304  : xdr_struct_base<field_ptr<::xdr::rpcb_entry_list,
305  decltype(::xdr::rpcb_entry_list::rpcb_entry_map),
306  &::xdr::rpcb_entry_list::rpcb_entry_map>,
307  field_ptr<::xdr::rpcb_entry_list,
308  decltype(::xdr::rpcb_entry_list::rpcb_entry_next),
309  &::xdr::rpcb_entry_list::rpcb_entry_next>> {
310  template<typename Archive> static void
311  save(Archive &ar, const ::xdr::rpcb_entry_list &obj) {
312  archive(ar, obj.rpcb_entry_map, "rpcb_entry_map");
313  archive(ar, obj.rpcb_entry_next, "rpcb_entry_next");
314  }
315  template<typename Archive> static void
316  load(Archive &ar, ::xdr::rpcb_entry_list &obj) {
317  archive(ar, obj.rpcb_entry_map, "rpcb_entry_map");
318  archive(ar, obj.rpcb_entry_next, "rpcb_entry_next");
319  xdr::validate(obj);
320  }
321 };
322 } namespace xdr {
323 
324 using rpcb_entry_list_ptr = xdr::pointer<rpcb_entry_list>;
325 
326 Constexpr const std::uint32_t rpcb_highproc_2 = 5;
327 Constexpr const std::uint32_t rpcb_highproc_3 = 8;
328 Constexpr const std::uint32_t rpcb_highproc_4 = 12;
329 Constexpr const std::uint32_t RPCBSTAT_HIGHPROC = 13;
330 Constexpr const std::uint32_t RPCBVERS_STAT = 3;
331 Constexpr const std::uint32_t RPCBVERS_4_STAT = 2;
332 Constexpr const std::uint32_t RPCBVERS_3_STAT = 1;
333 Constexpr const std::uint32_t RPCBVERS_2_STAT = 0;
334 
335 struct rpcbs_addrlist {
336  std::uint32_t prog{};
337  std::uint32_t vers{};
338  std::int32_t success{};
339  std::int32_t failure{};
340  xdr::xstring<> netid{};
341  xdr::pointer<rpcbs_addrlist> next{};
342 
343  rpcbs_addrlist() = default;
344  template<typename _prog_T,
345  typename _vers_T,
346  typename _success_T,
347  typename _failure_T,
348  typename _netid_T,
349  typename _next_T,
350  typename = typename
351  std::enable_if<std::is_constructible<std::uint32_t, _prog_T>::value
352  && std::is_constructible<std::uint32_t, _vers_T>::value
353  && std::is_constructible<std::int32_t, _success_T>::value
354  && std::is_constructible<std::int32_t, _failure_T>::value
355  && std::is_constructible<xdr::xstring<>, _netid_T>::value
356  && std::is_constructible<xdr::pointer<rpcbs_addrlist>, _next_T>::value
357  >::type>
358  explicit rpcbs_addrlist(_prog_T &&_prog,
359  _vers_T &&_vers,
360  _success_T &&_success,
361  _failure_T &&_failure,
362  _netid_T &&_netid,
363  _next_T &&_next)
364  : prog(std::forward<_prog_T>(_prog)),
365  vers(std::forward<_vers_T>(_vers)),
366  success(std::forward<_success_T>(_success)),
367  failure(std::forward<_failure_T>(_failure)),
368  netid(std::forward<_netid_T>(_netid)),
369  next(std::forward<_next_T>(_next)) {}
370 };
371 } namespace xdr {
372 template<> struct xdr_traits<::xdr::rpcbs_addrlist>
373  : xdr_struct_base<field_ptr<::xdr::rpcbs_addrlist,
374  decltype(::xdr::rpcbs_addrlist::prog),
375  &::xdr::rpcbs_addrlist::prog>,
376  field_ptr<::xdr::rpcbs_addrlist,
377  decltype(::xdr::rpcbs_addrlist::vers),
378  &::xdr::rpcbs_addrlist::vers>,
379  field_ptr<::xdr::rpcbs_addrlist,
380  decltype(::xdr::rpcbs_addrlist::success),
381  &::xdr::rpcbs_addrlist::success>,
382  field_ptr<::xdr::rpcbs_addrlist,
383  decltype(::xdr::rpcbs_addrlist::failure),
384  &::xdr::rpcbs_addrlist::failure>,
385  field_ptr<::xdr::rpcbs_addrlist,
386  decltype(::xdr::rpcbs_addrlist::netid),
387  &::xdr::rpcbs_addrlist::netid>,
388  field_ptr<::xdr::rpcbs_addrlist,
389  decltype(::xdr::rpcbs_addrlist::next),
390  &::xdr::rpcbs_addrlist::next>> {
391  template<typename Archive> static void
392  save(Archive &ar, const ::xdr::rpcbs_addrlist &obj) {
393  archive(ar, obj.prog, "prog");
394  archive(ar, obj.vers, "vers");
395  archive(ar, obj.success, "success");
396  archive(ar, obj.failure, "failure");
397  archive(ar, obj.netid, "netid");
398  archive(ar, obj.next, "next");
399  }
400  template<typename Archive> static void
401  load(Archive &ar, ::xdr::rpcbs_addrlist &obj) {
402  archive(ar, obj.prog, "prog");
403  archive(ar, obj.vers, "vers");
404  archive(ar, obj.success, "success");
405  archive(ar, obj.failure, "failure");
406  archive(ar, obj.netid, "netid");
407  archive(ar, obj.next, "next");
408  xdr::validate(obj);
409  }
410 };
411 } namespace xdr {
412 
413 struct rpcbs_rmtcalllist {
414  std::uint32_t prog{};
415  std::uint32_t vers{};
416  std::uint32_t proc{};
417  std::int32_t success{};
418  std::int32_t failure{};
419  std::int32_t indirect{};
420  xdr::xstring<> netid{};
421  xdr::pointer<rpcbs_rmtcalllist> next{};
422 
423  rpcbs_rmtcalllist() = default;
424  template<typename _prog_T,
425  typename _vers_T,
426  typename _proc_T,
427  typename _success_T,
428  typename _failure_T,
429  typename _indirect_T,
430  typename _netid_T,
431  typename _next_T,
432  typename = typename
433  std::enable_if<std::is_constructible<std::uint32_t, _prog_T>::value
434  && std::is_constructible<std::uint32_t, _vers_T>::value
435  && std::is_constructible<std::uint32_t, _proc_T>::value
436  && std::is_constructible<std::int32_t, _success_T>::value
437  && std::is_constructible<std::int32_t, _failure_T>::value
438  && std::is_constructible<std::int32_t, _indirect_T>::value
439  && std::is_constructible<xdr::xstring<>, _netid_T>::value
440  && std::is_constructible<xdr::pointer<rpcbs_rmtcalllist>, _next_T>::value
441  >::type>
442  explicit rpcbs_rmtcalllist(_prog_T &&_prog,
443  _vers_T &&_vers,
444  _proc_T &&_proc,
445  _success_T &&_success,
446  _failure_T &&_failure,
447  _indirect_T &&_indirect,
448  _netid_T &&_netid,
449  _next_T &&_next)
450  : prog(std::forward<_prog_T>(_prog)),
451  vers(std::forward<_vers_T>(_vers)),
452  proc(std::forward<_proc_T>(_proc)),
453  success(std::forward<_success_T>(_success)),
454  failure(std::forward<_failure_T>(_failure)),
455  indirect(std::forward<_indirect_T>(_indirect)),
456  netid(std::forward<_netid_T>(_netid)),
457  next(std::forward<_next_T>(_next)) {}
458 };
459 } namespace xdr {
460 template<> struct xdr_traits<::xdr::rpcbs_rmtcalllist>
461  : xdr_struct_base<field_ptr<::xdr::rpcbs_rmtcalllist,
462  decltype(::xdr::rpcbs_rmtcalllist::prog),
463  &::xdr::rpcbs_rmtcalllist::prog>,
464  field_ptr<::xdr::rpcbs_rmtcalllist,
465  decltype(::xdr::rpcbs_rmtcalllist::vers),
466  &::xdr::rpcbs_rmtcalllist::vers>,
467  field_ptr<::xdr::rpcbs_rmtcalllist,
468  decltype(::xdr::rpcbs_rmtcalllist::proc),
469  &::xdr::rpcbs_rmtcalllist::proc>,
470  field_ptr<::xdr::rpcbs_rmtcalllist,
471  decltype(::xdr::rpcbs_rmtcalllist::success),
472  &::xdr::rpcbs_rmtcalllist::success>,
473  field_ptr<::xdr::rpcbs_rmtcalllist,
474  decltype(::xdr::rpcbs_rmtcalllist::failure),
475  &::xdr::rpcbs_rmtcalllist::failure>,
476  field_ptr<::xdr::rpcbs_rmtcalllist,
477  decltype(::xdr::rpcbs_rmtcalllist::indirect),
478  &::xdr::rpcbs_rmtcalllist::indirect>,
479  field_ptr<::xdr::rpcbs_rmtcalllist,
480  decltype(::xdr::rpcbs_rmtcalllist::netid),
481  &::xdr::rpcbs_rmtcalllist::netid>,
482  field_ptr<::xdr::rpcbs_rmtcalllist,
483  decltype(::xdr::rpcbs_rmtcalllist::next),
484  &::xdr::rpcbs_rmtcalllist::next>> {
485  template<typename Archive> static void
486  save(Archive &ar, const ::xdr::rpcbs_rmtcalllist &obj) {
487  archive(ar, obj.prog, "prog");
488  archive(ar, obj.vers, "vers");
489  archive(ar, obj.proc, "proc");
490  archive(ar, obj.success, "success");
491  archive(ar, obj.failure, "failure");
492  archive(ar, obj.indirect, "indirect");
493  archive(ar, obj.netid, "netid");
494  archive(ar, obj.next, "next");
495  }
496  template<typename Archive> static void
497  load(Archive &ar, ::xdr::rpcbs_rmtcalllist &obj) {
498  archive(ar, obj.prog, "prog");
499  archive(ar, obj.vers, "vers");
500  archive(ar, obj.proc, "proc");
501  archive(ar, obj.success, "success");
502  archive(ar, obj.failure, "failure");
503  archive(ar, obj.indirect, "indirect");
504  archive(ar, obj.netid, "netid");
505  archive(ar, obj.next, "next");
506  xdr::validate(obj);
507  }
508 };
509 } namespace xdr {
510 
511 using rpcbs_proc = xdr::xarray<std::int32_t,RPCBSTAT_HIGHPROC>;
512 using rpcbs_addrlist_ptr = xdr::pointer<rpcbs_addrlist>;
513 using rpcbs_rmtcalllist_ptr = xdr::pointer<rpcbs_rmtcalllist>;
514 
515 struct rpcb_stat {
516  rpcbs_proc info{};
517  std::int32_t setinfo{};
518  std::int32_t unsetinfo{};
519  rpcbs_addrlist_ptr addrinfo{};
520  rpcbs_rmtcalllist_ptr rmtinfo{};
521 
522  rpcb_stat() = default;
523  template<typename _info_T,
524  typename _setinfo_T,
525  typename _unsetinfo_T,
526  typename _addrinfo_T,
527  typename _rmtinfo_T,
528  typename = typename
529  std::enable_if<std::is_constructible<rpcbs_proc, _info_T>::value
530  && std::is_constructible<std::int32_t, _setinfo_T>::value
531  && std::is_constructible<std::int32_t, _unsetinfo_T>::value
532  && std::is_constructible<rpcbs_addrlist_ptr, _addrinfo_T>::value
533  && std::is_constructible<rpcbs_rmtcalllist_ptr, _rmtinfo_T>::value
534  >::type>
535  explicit rpcb_stat(_info_T &&_info,
536  _setinfo_T &&_setinfo,
537  _unsetinfo_T &&_unsetinfo,
538  _addrinfo_T &&_addrinfo,
539  _rmtinfo_T &&_rmtinfo)
540  : info(std::forward<_info_T>(_info)),
541  setinfo(std::forward<_setinfo_T>(_setinfo)),
542  unsetinfo(std::forward<_unsetinfo_T>(_unsetinfo)),
543  addrinfo(std::forward<_addrinfo_T>(_addrinfo)),
544  rmtinfo(std::forward<_rmtinfo_T>(_rmtinfo)) {}
545 };
546 } namespace xdr {
547 template<> struct xdr_traits<::xdr::rpcb_stat>
548  : xdr_struct_base<field_ptr<::xdr::rpcb_stat,
549  decltype(::xdr::rpcb_stat::info),
550  &::xdr::rpcb_stat::info>,
551  field_ptr<::xdr::rpcb_stat,
552  decltype(::xdr::rpcb_stat::setinfo),
553  &::xdr::rpcb_stat::setinfo>,
554  field_ptr<::xdr::rpcb_stat,
555  decltype(::xdr::rpcb_stat::unsetinfo),
556  &::xdr::rpcb_stat::unsetinfo>,
557  field_ptr<::xdr::rpcb_stat,
558  decltype(::xdr::rpcb_stat::addrinfo),
559  &::xdr::rpcb_stat::addrinfo>,
560  field_ptr<::xdr::rpcb_stat,
561  decltype(::xdr::rpcb_stat::rmtinfo),
562  &::xdr::rpcb_stat::rmtinfo>> {
563  template<typename Archive> static void
564  save(Archive &ar, const ::xdr::rpcb_stat &obj) {
565  archive(ar, obj.info, "info");
566  archive(ar, obj.setinfo, "setinfo");
567  archive(ar, obj.unsetinfo, "unsetinfo");
568  archive(ar, obj.addrinfo, "addrinfo");
569  archive(ar, obj.rmtinfo, "rmtinfo");
570  }
571  template<typename Archive> static void
572  load(Archive &ar, ::xdr::rpcb_stat &obj) {
573  archive(ar, obj.info, "info");
574  archive(ar, obj.setinfo, "setinfo");
575  archive(ar, obj.unsetinfo, "unsetinfo");
576  archive(ar, obj.addrinfo, "addrinfo");
577  archive(ar, obj.rmtinfo, "rmtinfo");
578  xdr::validate(obj);
579  }
580 };
581 } namespace xdr {
582 
583 using rpcb_stat_byvers = xdr::xarray<rpcb_stat,RPCBVERS_STAT>;
584 
585 struct netbuf {
586  std::uint32_t maxlen{};
587  xdr::opaque_vec<> buf{};
588 
589  netbuf() = default;
590  template<typename _maxlen_T,
591  typename _buf_T,
592  typename = typename
593  std::enable_if<std::is_constructible<std::uint32_t, _maxlen_T>::value
594  && std::is_constructible<xdr::opaque_vec<>, _buf_T>::value
595  >::type>
596  explicit netbuf(_maxlen_T &&_maxlen,
597  _buf_T &&_buf)
598  : maxlen(std::forward<_maxlen_T>(_maxlen)),
599  buf(std::forward<_buf_T>(_buf)) {}
600 };
601 } namespace xdr {
602 template<> struct xdr_traits<::xdr::netbuf>
603  : xdr_struct_base<field_ptr<::xdr::netbuf,
604  decltype(::xdr::netbuf::maxlen),
605  &::xdr::netbuf::maxlen>,
606  field_ptr<::xdr::netbuf,
607  decltype(::xdr::netbuf::buf),
608  &::xdr::netbuf::buf>> {
609  template<typename Archive> static void
610  save(Archive &ar, const ::xdr::netbuf &obj) {
611  archive(ar, obj.maxlen, "maxlen");
612  archive(ar, obj.buf, "buf");
613  }
614  template<typename Archive> static void
615  load(Archive &ar, ::xdr::netbuf &obj) {
616  archive(ar, obj.maxlen, "maxlen");
617  archive(ar, obj.buf, "buf");
618  xdr::validate(obj);
619  }
620 };
621 } namespace xdr {
622 
623 using rpcb_string = xdr::xstring<>;
624 
625 struct RPCBVERS {
626  static Constexpr const std::uint32_t program = 100000;
627  static Constexpr const char *program_name() { return "RPCBPROG"; }
628  static Constexpr const std::uint32_t version = 3;
629  static Constexpr const char *version_name() { return "RPCBVERS"; }
630 
631  struct RPCBPROC3_SET_t {
632  using interface_type = RPCBVERS;
633  static Constexpr const std::uint32_t proc = 1;
634  static Constexpr const char *proc_name() { return "RPCBPROC3_SET"; }
635  using arg_type = rpcb;
636  using arg_tuple_type = std::tuple<rpcb>;
637  using res_type = bool;
638  using res_wire_type = bool;
639 
640  template<typename C, typename...A> static auto
641  dispatch(C &&c, A &&...a) ->
642  decltype(c.RPCBPROC3_SET(std::forward<A>(a)...)) {
643  return c.RPCBPROC3_SET(std::forward<A>(a)...);
644  }
645  };
646 
647  struct RPCBPROC3_UNSET_t {
648  using interface_type = RPCBVERS;
649  static Constexpr const std::uint32_t proc = 2;
650  static Constexpr const char *proc_name() { return "RPCBPROC3_UNSET"; }
651  using arg_type = rpcb;
652  using arg_tuple_type = std::tuple<rpcb>;
653  using res_type = bool;
654  using res_wire_type = bool;
655 
656  template<typename C, typename...A> static auto
657  dispatch(C &&c, A &&...a) ->
658  decltype(c.RPCBPROC3_UNSET(std::forward<A>(a)...)) {
659  return c.RPCBPROC3_UNSET(std::forward<A>(a)...);
660  }
661  };
662 
663  struct RPCBPROC3_GETADDR_t {
664  using interface_type = RPCBVERS;
665  static Constexpr const std::uint32_t proc = 3;
666  static Constexpr const char *proc_name() { return "RPCBPROC3_GETADDR"; }
667  using arg_type = rpcb;
668  using arg_tuple_type = std::tuple<rpcb>;
669  using res_type = rpcb_string;
670  using res_wire_type = rpcb_string;
671 
672  template<typename C, typename...A> static auto
673  dispatch(C &&c, A &&...a) ->
674  decltype(c.RPCBPROC3_GETADDR(std::forward<A>(a)...)) {
675  return c.RPCBPROC3_GETADDR(std::forward<A>(a)...);
676  }
677  };
678 
679  struct RPCBPROC3_DUMP_t {
680  using interface_type = RPCBVERS;
681  static Constexpr const std::uint32_t proc = 4;
682  static Constexpr const char *proc_name() { return "RPCBPROC3_DUMP"; }
683  using arg_type = void;
684  using arg_tuple_type = std::tuple<>;
685  using res_type = rpcblist_ptr;
686  using res_wire_type = rpcblist_ptr;
687 
688  template<typename C, typename...A> static auto
689  dispatch(C &&c, A &&...a) ->
690  decltype(c.RPCBPROC3_DUMP(std::forward<A>(a)...)) {
691  return c.RPCBPROC3_DUMP(std::forward<A>(a)...);
692  }
693  };
694 
695  struct RPCBPROC3_CALLIT_t {
696  using interface_type = RPCBVERS;
697  static Constexpr const std::uint32_t proc = 5;
698  static Constexpr const char *proc_name() { return "RPCBPROC3_CALLIT"; }
699  using arg_type = rpcb_rmtcallargs;
700  using arg_tuple_type = std::tuple<rpcb_rmtcallargs>;
701  using res_type = rpcb_rmtcallres;
702  using res_wire_type = rpcb_rmtcallres;
703 
704  template<typename C, typename...A> static auto
705  dispatch(C &&c, A &&...a) ->
706  decltype(c.RPCBPROC3_CALLIT(std::forward<A>(a)...)) {
707  return c.RPCBPROC3_CALLIT(std::forward<A>(a)...);
708  }
709  };
710 
711  struct RPCBPROC3_GETTIME_t {
712  using interface_type = RPCBVERS;
713  static Constexpr const std::uint32_t proc = 6;
714  static Constexpr const char *proc_name() { return "RPCBPROC3_GETTIME"; }
715  using arg_type = void;
716  using arg_tuple_type = std::tuple<>;
717  using res_type = unsigned;
718  using res_wire_type = unsigned;
719 
720  template<typename C, typename...A> static auto
721  dispatch(C &&c, A &&...a) ->
722  decltype(c.RPCBPROC3_GETTIME(std::forward<A>(a)...)) {
723  return c.RPCBPROC3_GETTIME(std::forward<A>(a)...);
724  }
725  };
726 
727  struct RPCBPROC3_UADDR2TADDR_t {
728  using interface_type = RPCBVERS;
729  static Constexpr const std::uint32_t proc = 7;
730  static Constexpr const char *proc_name() { return "RPCBPROC3_UADDR2TADDR"; }
731  using arg_type = rpcb_string;
732  using arg_tuple_type = std::tuple<rpcb_string>;
733  using res_type = netbuf;
734  using res_wire_type = netbuf;
735 
736  template<typename C, typename...A> static auto
737  dispatch(C &&c, A &&...a) ->
738  decltype(c.RPCBPROC3_UADDR2TADDR(std::forward<A>(a)...)) {
739  return c.RPCBPROC3_UADDR2TADDR(std::forward<A>(a)...);
740  }
741  };
742 
743  struct RPCBPROC3_TADDR2UADDR_t {
744  using interface_type = RPCBVERS;
745  static Constexpr const std::uint32_t proc = 8;
746  static Constexpr const char *proc_name() { return "RPCBPROC3_TADDR2UADDR"; }
747  using arg_type = netbuf;
748  using arg_tuple_type = std::tuple<netbuf>;
749  using res_type = rpcb_string;
750  using res_wire_type = rpcb_string;
751 
752  template<typename C, typename...A> static auto
753  dispatch(C &&c, A &&...a) ->
754  decltype(c.RPCBPROC3_TADDR2UADDR(std::forward<A>(a)...)) {
755  return c.RPCBPROC3_TADDR2UADDR(std::forward<A>(a)...);
756  }
757  };
758 
759  template<typename T, typename...A> static bool
760  call_dispatch(T &&t, std::uint32_t proc, A &&...a) {
761  switch(proc) {
762  case 1:
763  t.template dispatch<RPCBPROC3_SET_t>(std::forward<A>(a)...);
764  return true;
765  case 2:
766  t.template dispatch<RPCBPROC3_UNSET_t>(std::forward<A>(a)...);
767  return true;
768  case 3:
769  t.template dispatch<RPCBPROC3_GETADDR_t>(std::forward<A>(a)...);
770  return true;
771  case 4:
772  t.template dispatch<RPCBPROC3_DUMP_t>(std::forward<A>(a)...);
773  return true;
774  case 5:
775  t.template dispatch<RPCBPROC3_CALLIT_t>(std::forward<A>(a)...);
776  return true;
777  case 6:
778  t.template dispatch<RPCBPROC3_GETTIME_t>(std::forward<A>(a)...);
779  return true;
780  case 7:
781  t.template dispatch<RPCBPROC3_UADDR2TADDR_t>(std::forward<A>(a)...);
782  return true;
783  case 8:
784  t.template dispatch<RPCBPROC3_TADDR2UADDR_t>(std::forward<A>(a)...);
785  return true;
786  }
787  return false;
788  }
789 
790  template<typename _XDR_INVOKER> struct _xdr_client {
791  _XDR_INVOKER _xdr_invoker_;
792  template<typename...ARGS> _xdr_client(ARGS &&...args)
793  : _xdr_invoker_(std::forward<ARGS>(args)...) {}
794 
795  template<typename..._XDR_ARGS> auto
796  RPCBPROC3_SET(_XDR_ARGS &&..._xdr_args) ->
797  decltype(_xdr_invoker_->template invoke<RPCBPROC3_SET_t,
798  rpcb>(
799  std::forward<_XDR_ARGS>(_xdr_args)...)) {
800  return _xdr_invoker_->template invoke<RPCBPROC3_SET_t,
801  rpcb>(
802  std::forward<_XDR_ARGS>(_xdr_args)...);
803  }
804 
805  template<typename..._XDR_ARGS> auto
806  RPCBPROC3_UNSET(_XDR_ARGS &&..._xdr_args) ->
807  decltype(_xdr_invoker_->template invoke<RPCBPROC3_UNSET_t,
808  rpcb>(
809  std::forward<_XDR_ARGS>(_xdr_args)...)) {
810  return _xdr_invoker_->template invoke<RPCBPROC3_UNSET_t,
811  rpcb>(
812  std::forward<_XDR_ARGS>(_xdr_args)...);
813  }
814 
815  template<typename..._XDR_ARGS> auto
816  RPCBPROC3_GETADDR(_XDR_ARGS &&..._xdr_args) ->
817  decltype(_xdr_invoker_->template invoke<RPCBPROC3_GETADDR_t,
818  rpcb>(
819  std::forward<_XDR_ARGS>(_xdr_args)...)) {
820  return _xdr_invoker_->template invoke<RPCBPROC3_GETADDR_t,
821  rpcb>(
822  std::forward<_XDR_ARGS>(_xdr_args)...);
823  }
824 
825  template<typename..._XDR_ARGS> auto
826  RPCBPROC3_DUMP(_XDR_ARGS &&..._xdr_args) ->
827  decltype(_xdr_invoker_->template invoke<RPCBPROC3_DUMP_t>(
828  std::forward<_XDR_ARGS>(_xdr_args)...)) {
829  return _xdr_invoker_->template invoke<RPCBPROC3_DUMP_t>(
830  std::forward<_XDR_ARGS>(_xdr_args)...);
831  }
832 
833  template<typename..._XDR_ARGS> auto
834  RPCBPROC3_CALLIT(_XDR_ARGS &&..._xdr_args) ->
835  decltype(_xdr_invoker_->template invoke<RPCBPROC3_CALLIT_t,
836  rpcb_rmtcallargs>(
837  std::forward<_XDR_ARGS>(_xdr_args)...)) {
838  return _xdr_invoker_->template invoke<RPCBPROC3_CALLIT_t,
839  rpcb_rmtcallargs>(
840  std::forward<_XDR_ARGS>(_xdr_args)...);
841  }
842 
843  template<typename..._XDR_ARGS> auto
844  RPCBPROC3_GETTIME(_XDR_ARGS &&..._xdr_args) ->
845  decltype(_xdr_invoker_->template invoke<RPCBPROC3_GETTIME_t>(
846  std::forward<_XDR_ARGS>(_xdr_args)...)) {
847  return _xdr_invoker_->template invoke<RPCBPROC3_GETTIME_t>(
848  std::forward<_XDR_ARGS>(_xdr_args)...);
849  }
850 
851  template<typename..._XDR_ARGS> auto
852  RPCBPROC3_UADDR2TADDR(_XDR_ARGS &&..._xdr_args) ->
853  decltype(_xdr_invoker_->template invoke<RPCBPROC3_UADDR2TADDR_t,
854  rpcb_string>(
855  std::forward<_XDR_ARGS>(_xdr_args)...)) {
856  return _xdr_invoker_->template invoke<RPCBPROC3_UADDR2TADDR_t,
857  rpcb_string>(
858  std::forward<_XDR_ARGS>(_xdr_args)...);
859  }
860 
861  template<typename..._XDR_ARGS> auto
862  RPCBPROC3_TADDR2UADDR(_XDR_ARGS &&..._xdr_args) ->
863  decltype(_xdr_invoker_->template invoke<RPCBPROC3_TADDR2UADDR_t,
864  netbuf>(
865  std::forward<_XDR_ARGS>(_xdr_args)...)) {
866  return _xdr_invoker_->template invoke<RPCBPROC3_TADDR2UADDR_t,
867  netbuf>(
868  std::forward<_XDR_ARGS>(_xdr_args)...);
869  }
870  };
871 };
872 
873 struct RPCBVERS4 {
874  static Constexpr const std::uint32_t program = 100000;
875  static Constexpr const char *program_name() { return "RPCBPROG"; }
876  static Constexpr const std::uint32_t version = 4;
877  static Constexpr const char *version_name() { return "RPCBVERS4"; }
878 
879  struct RPCBPROC_SET_t {
880  using interface_type = RPCBVERS4;
881  static Constexpr const std::uint32_t proc = 1;
882  static Constexpr const char *proc_name() { return "RPCBPROC_SET"; }
883  using arg_type = rpcb;
884  using arg_tuple_type = std::tuple<rpcb>;
885  using res_type = bool;
886  using res_wire_type = bool;
887 
888  template<typename C, typename...A> static auto
889  dispatch(C &&c, A &&...a) ->
890  decltype(c.RPCBPROC_SET(std::forward<A>(a)...)) {
891  return c.RPCBPROC_SET(std::forward<A>(a)...);
892  }
893  };
894 
895  struct RPCBPROC_UNSET_t {
896  using interface_type = RPCBVERS4;
897  static Constexpr const std::uint32_t proc = 2;
898  static Constexpr const char *proc_name() { return "RPCBPROC_UNSET"; }
899  using arg_type = rpcb;
900  using arg_tuple_type = std::tuple<rpcb>;
901  using res_type = bool;
902  using res_wire_type = bool;
903 
904  template<typename C, typename...A> static auto
905  dispatch(C &&c, A &&...a) ->
906  decltype(c.RPCBPROC_UNSET(std::forward<A>(a)...)) {
907  return c.RPCBPROC_UNSET(std::forward<A>(a)...);
908  }
909  };
910 
911  struct RPCBPROC_GETADDR_t {
912  using interface_type = RPCBVERS4;
913  static Constexpr const std::uint32_t proc = 3;
914  static Constexpr const char *proc_name() { return "RPCBPROC_GETADDR"; }
915  using arg_type = rpcb;
916  using arg_tuple_type = std::tuple<rpcb>;
917  using res_type = rpcb_string;
918  using res_wire_type = rpcb_string;
919 
920  template<typename C, typename...A> static auto
921  dispatch(C &&c, A &&...a) ->
922  decltype(c.RPCBPROC_GETADDR(std::forward<A>(a)...)) {
923  return c.RPCBPROC_GETADDR(std::forward<A>(a)...);
924  }
925  };
926 
927  struct RPCBPROC_DUMP_t {
928  using interface_type = RPCBVERS4;
929  static Constexpr const std::uint32_t proc = 4;
930  static Constexpr const char *proc_name() { return "RPCBPROC_DUMP"; }
931  using arg_type = void;
932  using arg_tuple_type = std::tuple<>;
933  using res_type = rpcblist_ptr;
934  using res_wire_type = rpcblist_ptr;
935 
936  template<typename C, typename...A> static auto
937  dispatch(C &&c, A &&...a) ->
938  decltype(c.RPCBPROC_DUMP(std::forward<A>(a)...)) {
939  return c.RPCBPROC_DUMP(std::forward<A>(a)...);
940  }
941  };
942 
943  struct RPCBPROC_BCAST_t {
944  using interface_type = RPCBVERS4;
945  static Constexpr const std::uint32_t proc = 5;
946  static Constexpr const char *proc_name() { return "RPCBPROC_BCAST"; }
947  using arg_type = rpcb_rmtcallargs;
948  using arg_tuple_type = std::tuple<rpcb_rmtcallargs>;
949  using res_type = rpcb_rmtcallres;
950  using res_wire_type = rpcb_rmtcallres;
951 
952  template<typename C, typename...A> static auto
953  dispatch(C &&c, A &&...a) ->
954  decltype(c.RPCBPROC_BCAST(std::forward<A>(a)...)) {
955  return c.RPCBPROC_BCAST(std::forward<A>(a)...);
956  }
957  };
958 
959  struct RPCBPROC_GETTIME_t {
960  using interface_type = RPCBVERS4;
961  static Constexpr const std::uint32_t proc = 6;
962  static Constexpr const char *proc_name() { return "RPCBPROC_GETTIME"; }
963  using arg_type = void;
964  using arg_tuple_type = std::tuple<>;
965  using res_type = unsigned;
966  using res_wire_type = unsigned;
967 
968  template<typename C, typename...A> static auto
969  dispatch(C &&c, A &&...a) ->
970  decltype(c.RPCBPROC_GETTIME(std::forward<A>(a)...)) {
971  return c.RPCBPROC_GETTIME(std::forward<A>(a)...);
972  }
973  };
974 
975  struct RPCBPROC_UADDR2TADDR_t {
976  using interface_type = RPCBVERS4;
977  static Constexpr const std::uint32_t proc = 7;
978  static Constexpr const char *proc_name() { return "RPCBPROC_UADDR2TADDR"; }
979  using arg_type = rpcb_string;
980  using arg_tuple_type = std::tuple<rpcb_string>;
981  using res_type = netbuf;
982  using res_wire_type = netbuf;
983 
984  template<typename C, typename...A> static auto
985  dispatch(C &&c, A &&...a) ->
986  decltype(c.RPCBPROC_UADDR2TADDR(std::forward<A>(a)...)) {
987  return c.RPCBPROC_UADDR2TADDR(std::forward<A>(a)...);
988  }
989  };
990 
991  struct RPCBPROC_TADDR2UADDR_t {
992  using interface_type = RPCBVERS4;
993  static Constexpr const std::uint32_t proc = 8;
994  static Constexpr const char *proc_name() { return "RPCBPROC_TADDR2UADDR"; }
995  using arg_type = netbuf;
996  using arg_tuple_type = std::tuple<netbuf>;
997  using res_type = rpcb_string;
998  using res_wire_type = rpcb_string;
999 
1000  template<typename C, typename...A> static auto
1001  dispatch(C &&c, A &&...a) ->
1002  decltype(c.RPCBPROC_TADDR2UADDR(std::forward<A>(a)...)) {
1003  return c.RPCBPROC_TADDR2UADDR(std::forward<A>(a)...);
1004  }
1005  };
1006 
1007  struct RPCBPROC_GETVERSADDR_t {
1008  using interface_type = RPCBVERS4;
1009  static Constexpr const std::uint32_t proc = 9;
1010  static Constexpr const char *proc_name() { return "RPCBPROC_GETVERSADDR"; }
1011  using arg_type = rpcb;
1012  using arg_tuple_type = std::tuple<rpcb>;
1013  using res_type = rpcb_string;
1014  using res_wire_type = rpcb_string;
1015 
1016  template<typename C, typename...A> static auto
1017  dispatch(C &&c, A &&...a) ->
1018  decltype(c.RPCBPROC_GETVERSADDR(std::forward<A>(a)...)) {
1019  return c.RPCBPROC_GETVERSADDR(std::forward<A>(a)...);
1020  }
1021  };
1022 
1023  struct RPCBPROC_INDIRECT_t {
1024  using interface_type = RPCBVERS4;
1025  static Constexpr const std::uint32_t proc = 10;
1026  static Constexpr const char *proc_name() { return "RPCBPROC_INDIRECT"; }
1027  using arg_type = rpcb_rmtcallargs;
1028  using arg_tuple_type = std::tuple<rpcb_rmtcallargs>;
1029  using res_type = rpcb_rmtcallres;
1030  using res_wire_type = rpcb_rmtcallres;
1031 
1032  template<typename C, typename...A> static auto
1033  dispatch(C &&c, A &&...a) ->
1034  decltype(c.RPCBPROC_INDIRECT(std::forward<A>(a)...)) {
1035  return c.RPCBPROC_INDIRECT(std::forward<A>(a)...);
1036  }
1037  };
1038 
1039  struct RPCBPROC_GETADDRLIST_t {
1040  using interface_type = RPCBVERS4;
1041  static Constexpr const std::uint32_t proc = 11;
1042  static Constexpr const char *proc_name() { return "RPCBPROC_GETADDRLIST"; }
1043  using arg_type = rpcb;
1044  using arg_tuple_type = std::tuple<rpcb>;
1045  using res_type = rpcb_entry_list_ptr;
1046  using res_wire_type = rpcb_entry_list_ptr;
1047 
1048  template<typename C, typename...A> static auto
1049  dispatch(C &&c, A &&...a) ->
1050  decltype(c.RPCBPROC_GETADDRLIST(std::forward<A>(a)...)) {
1051  return c.RPCBPROC_GETADDRLIST(std::forward<A>(a)...);
1052  }
1053  };
1054 
1055  struct RPCBPROC_GETSTAT_t {
1056  using interface_type = RPCBVERS4;
1057  static Constexpr const std::uint32_t proc = 12;
1058  static Constexpr const char *proc_name() { return "RPCBPROC_GETSTAT"; }
1059  using arg_type = void;
1060  using arg_tuple_type = std::tuple<>;
1061  using res_type = rpcb_stat_byvers;
1062  using res_wire_type = rpcb_stat_byvers;
1063 
1064  template<typename C, typename...A> static auto
1065  dispatch(C &&c, A &&...a) ->
1066  decltype(c.RPCBPROC_GETSTAT(std::forward<A>(a)...)) {
1067  return c.RPCBPROC_GETSTAT(std::forward<A>(a)...);
1068  }
1069  };
1070 
1071  template<typename T, typename...A> static bool
1072  call_dispatch(T &&t, std::uint32_t proc, A &&...a) {
1073  switch(proc) {
1074  case 1:
1075  t.template dispatch<RPCBPROC_SET_t>(std::forward<A>(a)...);
1076  return true;
1077  case 2:
1078  t.template dispatch<RPCBPROC_UNSET_t>(std::forward<A>(a)...);
1079  return true;
1080  case 3:
1081  t.template dispatch<RPCBPROC_GETADDR_t>(std::forward<A>(a)...);
1082  return true;
1083  case 4:
1084  t.template dispatch<RPCBPROC_DUMP_t>(std::forward<A>(a)...);
1085  return true;
1086  case 5:
1087  t.template dispatch<RPCBPROC_BCAST_t>(std::forward<A>(a)...);
1088  return true;
1089  case 6:
1090  t.template dispatch<RPCBPROC_GETTIME_t>(std::forward<A>(a)...);
1091  return true;
1092  case 7:
1093  t.template dispatch<RPCBPROC_UADDR2TADDR_t>(std::forward<A>(a)...);
1094  return true;
1095  case 8:
1096  t.template dispatch<RPCBPROC_TADDR2UADDR_t>(std::forward<A>(a)...);
1097  return true;
1098  case 9:
1099  t.template dispatch<RPCBPROC_GETVERSADDR_t>(std::forward<A>(a)...);
1100  return true;
1101  case 10:
1102  t.template dispatch<RPCBPROC_INDIRECT_t>(std::forward<A>(a)...);
1103  return true;
1104  case 11:
1105  t.template dispatch<RPCBPROC_GETADDRLIST_t>(std::forward<A>(a)...);
1106  return true;
1107  case 12:
1108  t.template dispatch<RPCBPROC_GETSTAT_t>(std::forward<A>(a)...);
1109  return true;
1110  }
1111  return false;
1112  }
1113 
1114  template<typename _XDR_INVOKER> struct _xdr_client {
1115  _XDR_INVOKER _xdr_invoker_;
1116  template<typename...ARGS> _xdr_client(ARGS &&...args)
1117  : _xdr_invoker_(std::forward<ARGS>(args)...) {}
1118 
1119  template<typename..._XDR_ARGS> auto
1120  RPCBPROC_SET(_XDR_ARGS &&..._xdr_args) ->
1121  decltype(_xdr_invoker_->template invoke<RPCBPROC_SET_t,
1122  rpcb>(
1123  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1124  return _xdr_invoker_->template invoke<RPCBPROC_SET_t,
1125  rpcb>(
1126  std::forward<_XDR_ARGS>(_xdr_args)...);
1127  }
1128 
1129  template<typename..._XDR_ARGS> auto
1130  RPCBPROC_UNSET(_XDR_ARGS &&..._xdr_args) ->
1131  decltype(_xdr_invoker_->template invoke<RPCBPROC_UNSET_t,
1132  rpcb>(
1133  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1134  return _xdr_invoker_->template invoke<RPCBPROC_UNSET_t,
1135  rpcb>(
1136  std::forward<_XDR_ARGS>(_xdr_args)...);
1137  }
1138 
1139  template<typename..._XDR_ARGS> auto
1140  RPCBPROC_GETADDR(_XDR_ARGS &&..._xdr_args) ->
1141  decltype(_xdr_invoker_->template invoke<RPCBPROC_GETADDR_t,
1142  rpcb>(
1143  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1144  return _xdr_invoker_->template invoke<RPCBPROC_GETADDR_t,
1145  rpcb>(
1146  std::forward<_XDR_ARGS>(_xdr_args)...);
1147  }
1148 
1149  template<typename..._XDR_ARGS> auto
1150  RPCBPROC_DUMP(_XDR_ARGS &&..._xdr_args) ->
1151  decltype(_xdr_invoker_->template invoke<RPCBPROC_DUMP_t>(
1152  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1153  return _xdr_invoker_->template invoke<RPCBPROC_DUMP_t>(
1154  std::forward<_XDR_ARGS>(_xdr_args)...);
1155  }
1156 
1157  template<typename..._XDR_ARGS> auto
1158  RPCBPROC_BCAST(_XDR_ARGS &&..._xdr_args) ->
1159  decltype(_xdr_invoker_->template invoke<RPCBPROC_BCAST_t,
1160  rpcb_rmtcallargs>(
1161  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1162  return _xdr_invoker_->template invoke<RPCBPROC_BCAST_t,
1163  rpcb_rmtcallargs>(
1164  std::forward<_XDR_ARGS>(_xdr_args)...);
1165  }
1166 
1167  template<typename..._XDR_ARGS> auto
1168  RPCBPROC_GETTIME(_XDR_ARGS &&..._xdr_args) ->
1169  decltype(_xdr_invoker_->template invoke<RPCBPROC_GETTIME_t>(
1170  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1171  return _xdr_invoker_->template invoke<RPCBPROC_GETTIME_t>(
1172  std::forward<_XDR_ARGS>(_xdr_args)...);
1173  }
1174 
1175  template<typename..._XDR_ARGS> auto
1176  RPCBPROC_UADDR2TADDR(_XDR_ARGS &&..._xdr_args) ->
1177  decltype(_xdr_invoker_->template invoke<RPCBPROC_UADDR2TADDR_t,
1178  rpcb_string>(
1179  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1180  return _xdr_invoker_->template invoke<RPCBPROC_UADDR2TADDR_t,
1181  rpcb_string>(
1182  std::forward<_XDR_ARGS>(_xdr_args)...);
1183  }
1184 
1185  template<typename..._XDR_ARGS> auto
1186  RPCBPROC_TADDR2UADDR(_XDR_ARGS &&..._xdr_args) ->
1187  decltype(_xdr_invoker_->template invoke<RPCBPROC_TADDR2UADDR_t,
1188  netbuf>(
1189  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1190  return _xdr_invoker_->template invoke<RPCBPROC_TADDR2UADDR_t,
1191  netbuf>(
1192  std::forward<_XDR_ARGS>(_xdr_args)...);
1193  }
1194 
1195  template<typename..._XDR_ARGS> auto
1196  RPCBPROC_GETVERSADDR(_XDR_ARGS &&..._xdr_args) ->
1197  decltype(_xdr_invoker_->template invoke<RPCBPROC_GETVERSADDR_t,
1198  rpcb>(
1199  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1200  return _xdr_invoker_->template invoke<RPCBPROC_GETVERSADDR_t,
1201  rpcb>(
1202  std::forward<_XDR_ARGS>(_xdr_args)...);
1203  }
1204 
1205  template<typename..._XDR_ARGS> auto
1206  RPCBPROC_INDIRECT(_XDR_ARGS &&..._xdr_args) ->
1207  decltype(_xdr_invoker_->template invoke<RPCBPROC_INDIRECT_t,
1208  rpcb_rmtcallargs>(
1209  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1210  return _xdr_invoker_->template invoke<RPCBPROC_INDIRECT_t,
1211  rpcb_rmtcallargs>(
1212  std::forward<_XDR_ARGS>(_xdr_args)...);
1213  }
1214 
1215  template<typename..._XDR_ARGS> auto
1216  RPCBPROC_GETADDRLIST(_XDR_ARGS &&..._xdr_args) ->
1217  decltype(_xdr_invoker_->template invoke<RPCBPROC_GETADDRLIST_t,
1218  rpcb>(
1219  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1220  return _xdr_invoker_->template invoke<RPCBPROC_GETADDRLIST_t,
1221  rpcb>(
1222  std::forward<_XDR_ARGS>(_xdr_args)...);
1223  }
1224 
1225  template<typename..._XDR_ARGS> auto
1226  RPCBPROC_GETSTAT(_XDR_ARGS &&..._xdr_args) ->
1227  decltype(_xdr_invoker_->template invoke<RPCBPROC_GETSTAT_t>(
1228  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1229  return _xdr_invoker_->template invoke<RPCBPROC_GETSTAT_t>(
1230  std::forward<_XDR_ARGS>(_xdr_args)...);
1231  }
1232  };
1233 };
1234 
1235 Constexpr const std::uint32_t PMAP_PORT = 111;
1236 
1237 struct mapping {
1238  std::uint32_t prog{};
1239  std::uint32_t vers{};
1240  std::uint32_t prot{};
1241  std::uint32_t port{};
1242 
1243  mapping() = default;
1244  template<typename _prog_T,
1245  typename _vers_T,
1246  typename _prot_T,
1247  typename _port_T,
1248  typename = typename
1249  std::enable_if<std::is_constructible<std::uint32_t, _prog_T>::value
1250  && std::is_constructible<std::uint32_t, _vers_T>::value
1251  && std::is_constructible<std::uint32_t, _prot_T>::value
1252  && std::is_constructible<std::uint32_t, _port_T>::value
1253  >::type>
1254  explicit mapping(_prog_T &&_prog,
1255  _vers_T &&_vers,
1256  _prot_T &&_prot,
1257  _port_T &&_port)
1258  : prog(std::forward<_prog_T>(_prog)),
1259  vers(std::forward<_vers_T>(_vers)),
1260  prot(std::forward<_prot_T>(_prot)),
1261  port(std::forward<_port_T>(_port)) {}
1262 };
1263 } namespace xdr {
1264 template<> struct xdr_traits<::xdr::mapping>
1265  : xdr_struct_base<field_ptr<::xdr::mapping,
1266  decltype(::xdr::mapping::prog),
1267  &::xdr::mapping::prog>,
1268  field_ptr<::xdr::mapping,
1269  decltype(::xdr::mapping::vers),
1270  &::xdr::mapping::vers>,
1271  field_ptr<::xdr::mapping,
1272  decltype(::xdr::mapping::prot),
1273  &::xdr::mapping::prot>,
1274  field_ptr<::xdr::mapping,
1275  decltype(::xdr::mapping::port),
1276  &::xdr::mapping::port>> {
1277  template<typename Archive> static void
1278  save(Archive &ar, const ::xdr::mapping &obj) {
1279  archive(ar, obj.prog, "prog");
1280  archive(ar, obj.vers, "vers");
1281  archive(ar, obj.prot, "prot");
1282  archive(ar, obj.port, "port");
1283  }
1284  template<typename Archive> static void
1285  load(Archive &ar, ::xdr::mapping &obj) {
1286  archive(ar, obj.prog, "prog");
1287  archive(ar, obj.vers, "vers");
1288  archive(ar, obj.prot, "prot");
1289  archive(ar, obj.port, "port");
1290  xdr::validate(obj);
1291  }
1292 };
1293 } namespace xdr {
1294 
1295 struct pmaplist_entry {
1296  mapping map{};
1297  xdr::pointer<pmaplist_entry> next{};
1298 
1299  pmaplist_entry() = default;
1300  template<typename _map_T,
1301  typename _next_T,
1302  typename = typename
1303  std::enable_if<std::is_constructible<mapping, _map_T>::value
1304  && std::is_constructible<xdr::pointer<pmaplist_entry>, _next_T>::value
1305  >::type>
1306  explicit pmaplist_entry(_map_T &&_map,
1307  _next_T &&_next)
1308  : map(std::forward<_map_T>(_map)),
1309  next(std::forward<_next_T>(_next)) {}
1310 };
1311 } namespace xdr {
1312 template<> struct xdr_traits<::xdr::pmaplist_entry>
1313  : xdr_struct_base<field_ptr<::xdr::pmaplist_entry,
1314  decltype(::xdr::pmaplist_entry::map),
1315  &::xdr::pmaplist_entry::map>,
1316  field_ptr<::xdr::pmaplist_entry,
1317  decltype(::xdr::pmaplist_entry::next),
1318  &::xdr::pmaplist_entry::next>> {
1319  template<typename Archive> static void
1320  save(Archive &ar, const ::xdr::pmaplist_entry &obj) {
1321  archive(ar, obj.map, "map");
1322  archive(ar, obj.next, "next");
1323  }
1324  template<typename Archive> static void
1325  load(Archive &ar, ::xdr::pmaplist_entry &obj) {
1326  archive(ar, obj.map, "map");
1327  archive(ar, obj.next, "next");
1328  xdr::validate(obj);
1329  }
1330 };
1331 } namespace xdr {
1332 
1333 using pmaplist = xdr::pointer<pmaplist_entry>;
1334 
1335 struct call_args {
1336  std::uint32_t prog{};
1337  std::uint32_t vers{};
1338  std::uint32_t proc{};
1339  xdr::opaque_vec<> args{};
1340 
1341  call_args() = default;
1342  template<typename _prog_T,
1343  typename _vers_T,
1344  typename _proc_T,
1345  typename _args_T,
1346  typename = typename
1347  std::enable_if<std::is_constructible<std::uint32_t, _prog_T>::value
1348  && std::is_constructible<std::uint32_t, _vers_T>::value
1349  && std::is_constructible<std::uint32_t, _proc_T>::value
1350  && std::is_constructible<xdr::opaque_vec<>, _args_T>::value
1351  >::type>
1352  explicit call_args(_prog_T &&_prog,
1353  _vers_T &&_vers,
1354  _proc_T &&_proc,
1355  _args_T &&_args)
1356  : prog(std::forward<_prog_T>(_prog)),
1357  vers(std::forward<_vers_T>(_vers)),
1358  proc(std::forward<_proc_T>(_proc)),
1359  args(std::forward<_args_T>(_args)) {}
1360 };
1361 } namespace xdr {
1362 template<> struct xdr_traits<::xdr::call_args>
1363  : xdr_struct_base<field_ptr<::xdr::call_args,
1364  decltype(::xdr::call_args::prog),
1365  &::xdr::call_args::prog>,
1366  field_ptr<::xdr::call_args,
1367  decltype(::xdr::call_args::vers),
1368  &::xdr::call_args::vers>,
1369  field_ptr<::xdr::call_args,
1370  decltype(::xdr::call_args::proc),
1371  &::xdr::call_args::proc>,
1372  field_ptr<::xdr::call_args,
1373  decltype(::xdr::call_args::args),
1374  &::xdr::call_args::args>> {
1375  template<typename Archive> static void
1376  save(Archive &ar, const ::xdr::call_args &obj) {
1377  archive(ar, obj.prog, "prog");
1378  archive(ar, obj.vers, "vers");
1379  archive(ar, obj.proc, "proc");
1380  archive(ar, obj.args, "args");
1381  }
1382  template<typename Archive> static void
1383  load(Archive &ar, ::xdr::call_args &obj) {
1384  archive(ar, obj.prog, "prog");
1385  archive(ar, obj.vers, "vers");
1386  archive(ar, obj.proc, "proc");
1387  archive(ar, obj.args, "args");
1388  xdr::validate(obj);
1389  }
1390 };
1391 } namespace xdr {
1392 
1393 struct call_result {
1394  std::uint32_t port{};
1395  xdr::opaque_vec<> res{};
1396 
1397  call_result() = default;
1398  template<typename _port_T,
1399  typename _res_T,
1400  typename = typename
1401  std::enable_if<std::is_constructible<std::uint32_t, _port_T>::value
1402  && std::is_constructible<xdr::opaque_vec<>, _res_T>::value
1403  >::type>
1404  explicit call_result(_port_T &&_port,
1405  _res_T &&_res)
1406  : port(std::forward<_port_T>(_port)),
1407  res(std::forward<_res_T>(_res)) {}
1408 };
1409 } namespace xdr {
1410 template<> struct xdr_traits<::xdr::call_result>
1411  : xdr_struct_base<field_ptr<::xdr::call_result,
1412  decltype(::xdr::call_result::port),
1413  &::xdr::call_result::port>,
1414  field_ptr<::xdr::call_result,
1415  decltype(::xdr::call_result::res),
1416  &::xdr::call_result::res>> {
1417  template<typename Archive> static void
1418  save(Archive &ar, const ::xdr::call_result &obj) {
1419  archive(ar, obj.port, "port");
1420  archive(ar, obj.res, "res");
1421  }
1422  template<typename Archive> static void
1423  load(Archive &ar, ::xdr::call_result &obj) {
1424  archive(ar, obj.port, "port");
1425  archive(ar, obj.res, "res");
1426  xdr::validate(obj);
1427  }
1428 };
1429 } namespace xdr {
1430 
1431 struct PMAP_VERS {
1432  static Constexpr const std::uint32_t program = 100000;
1433  static Constexpr const char *program_name() { return "PMAP_PROG"; }
1434  static Constexpr const std::uint32_t version = 2;
1435  static Constexpr const char *version_name() { return "PMAP_VERS"; }
1436 
1437  struct PMAPPROC_NULL_t {
1438  using interface_type = PMAP_VERS;
1439  static Constexpr const std::uint32_t proc = 0;
1440  static Constexpr const char *proc_name() { return "PMAPPROC_NULL"; }
1441  using arg_type = void;
1442  using arg_tuple_type = std::tuple<>;
1443  using res_type = void;
1444  using res_wire_type = xdr::xdr_void;
1445 
1446  template<typename C, typename...A> static auto
1447  dispatch(C &&c, A &&...a) ->
1448  decltype(c.PMAPPROC_NULL(std::forward<A>(a)...)) {
1449  return c.PMAPPROC_NULL(std::forward<A>(a)...);
1450  }
1451  };
1452 
1453  struct PMAPPROC_SET_t {
1454  using interface_type = PMAP_VERS;
1455  static Constexpr const std::uint32_t proc = 1;
1456  static Constexpr const char *proc_name() { return "PMAPPROC_SET"; }
1457  using arg_type = mapping;
1458  using arg_tuple_type = std::tuple<mapping>;
1459  using res_type = bool;
1460  using res_wire_type = bool;
1461 
1462  template<typename C, typename...A> static auto
1463  dispatch(C &&c, A &&...a) ->
1464  decltype(c.PMAPPROC_SET(std::forward<A>(a)...)) {
1465  return c.PMAPPROC_SET(std::forward<A>(a)...);
1466  }
1467  };
1468 
1469  struct PMAPPROC_UNSET_t {
1470  using interface_type = PMAP_VERS;
1471  static Constexpr const std::uint32_t proc = 2;
1472  static Constexpr const char *proc_name() { return "PMAPPROC_UNSET"; }
1473  using arg_type = mapping;
1474  using arg_tuple_type = std::tuple<mapping>;
1475  using res_type = bool;
1476  using res_wire_type = bool;
1477 
1478  template<typename C, typename...A> static auto
1479  dispatch(C &&c, A &&...a) ->
1480  decltype(c.PMAPPROC_UNSET(std::forward<A>(a)...)) {
1481  return c.PMAPPROC_UNSET(std::forward<A>(a)...);
1482  }
1483  };
1484 
1485  struct PMAPPROC_GETPORT_t {
1486  using interface_type = PMAP_VERS;
1487  static Constexpr const std::uint32_t proc = 3;
1488  static Constexpr const char *proc_name() { return "PMAPPROC_GETPORT"; }
1489  using arg_type = mapping;
1490  using arg_tuple_type = std::tuple<mapping>;
1491  using res_type = unsigned;
1492  using res_wire_type = unsigned;
1493 
1494  template<typename C, typename...A> static auto
1495  dispatch(C &&c, A &&...a) ->
1496  decltype(c.PMAPPROC_GETPORT(std::forward<A>(a)...)) {
1497  return c.PMAPPROC_GETPORT(std::forward<A>(a)...);
1498  }
1499  };
1500 
1501  struct PMAPPROC_DUMP_t {
1502  using interface_type = PMAP_VERS;
1503  static Constexpr const std::uint32_t proc = 4;
1504  static Constexpr const char *proc_name() { return "PMAPPROC_DUMP"; }
1505  using arg_type = void;
1506  using arg_tuple_type = std::tuple<>;
1507  using res_type = pmaplist;
1508  using res_wire_type = pmaplist;
1509 
1510  template<typename C, typename...A> static auto
1511  dispatch(C &&c, A &&...a) ->
1512  decltype(c.PMAPPROC_DUMP(std::forward<A>(a)...)) {
1513  return c.PMAPPROC_DUMP(std::forward<A>(a)...);
1514  }
1515  };
1516 
1517  struct PMAPPROC_CALLIT_t {
1518  using interface_type = PMAP_VERS;
1519  static Constexpr const std::uint32_t proc = 5;
1520  static Constexpr const char *proc_name() { return "PMAPPROC_CALLIT"; }
1521  using arg_type = call_args;
1522  using arg_tuple_type = std::tuple<call_args>;
1523  using res_type = call_result;
1524  using res_wire_type = call_result;
1525 
1526  template<typename C, typename...A> static auto
1527  dispatch(C &&c, A &&...a) ->
1528  decltype(c.PMAPPROC_CALLIT(std::forward<A>(a)...)) {
1529  return c.PMAPPROC_CALLIT(std::forward<A>(a)...);
1530  }
1531  };
1532 
1533  template<typename T, typename...A> static bool
1534  call_dispatch(T &&t, std::uint32_t proc, A &&...a) {
1535  switch(proc) {
1536  case 0:
1537  t.template dispatch<PMAPPROC_NULL_t>(std::forward<A>(a)...);
1538  return true;
1539  case 1:
1540  t.template dispatch<PMAPPROC_SET_t>(std::forward<A>(a)...);
1541  return true;
1542  case 2:
1543  t.template dispatch<PMAPPROC_UNSET_t>(std::forward<A>(a)...);
1544  return true;
1545  case 3:
1546  t.template dispatch<PMAPPROC_GETPORT_t>(std::forward<A>(a)...);
1547  return true;
1548  case 4:
1549  t.template dispatch<PMAPPROC_DUMP_t>(std::forward<A>(a)...);
1550  return true;
1551  case 5:
1552  t.template dispatch<PMAPPROC_CALLIT_t>(std::forward<A>(a)...);
1553  return true;
1554  }
1555  return false;
1556  }
1557 
1558  template<typename _XDR_INVOKER> struct _xdr_client {
1559  _XDR_INVOKER _xdr_invoker_;
1560  template<typename...ARGS> _xdr_client(ARGS &&...args)
1561  : _xdr_invoker_(std::forward<ARGS>(args)...) {}
1562 
1563  template<typename..._XDR_ARGS> auto
1564  PMAPPROC_NULL(_XDR_ARGS &&..._xdr_args) ->
1565  decltype(_xdr_invoker_->template invoke<PMAPPROC_NULL_t>(
1566  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1567  return _xdr_invoker_->template invoke<PMAPPROC_NULL_t>(
1568  std::forward<_XDR_ARGS>(_xdr_args)...);
1569  }
1570 
1571  template<typename..._XDR_ARGS> auto
1572  PMAPPROC_SET(_XDR_ARGS &&..._xdr_args) ->
1573  decltype(_xdr_invoker_->template invoke<PMAPPROC_SET_t,
1574  mapping>(
1575  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1576  return _xdr_invoker_->template invoke<PMAPPROC_SET_t,
1577  mapping>(
1578  std::forward<_XDR_ARGS>(_xdr_args)...);
1579  }
1580 
1581  template<typename..._XDR_ARGS> auto
1582  PMAPPROC_UNSET(_XDR_ARGS &&..._xdr_args) ->
1583  decltype(_xdr_invoker_->template invoke<PMAPPROC_UNSET_t,
1584  mapping>(
1585  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1586  return _xdr_invoker_->template invoke<PMAPPROC_UNSET_t,
1587  mapping>(
1588  std::forward<_XDR_ARGS>(_xdr_args)...);
1589  }
1590 
1591  template<typename..._XDR_ARGS> auto
1592  PMAPPROC_GETPORT(_XDR_ARGS &&..._xdr_args) ->
1593  decltype(_xdr_invoker_->template invoke<PMAPPROC_GETPORT_t,
1594  mapping>(
1595  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1596  return _xdr_invoker_->template invoke<PMAPPROC_GETPORT_t,
1597  mapping>(
1598  std::forward<_XDR_ARGS>(_xdr_args)...);
1599  }
1600 
1601  template<typename..._XDR_ARGS> auto
1602  PMAPPROC_DUMP(_XDR_ARGS &&..._xdr_args) ->
1603  decltype(_xdr_invoker_->template invoke<PMAPPROC_DUMP_t>(
1604  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1605  return _xdr_invoker_->template invoke<PMAPPROC_DUMP_t>(
1606  std::forward<_XDR_ARGS>(_xdr_args)...);
1607  }
1608 
1609  template<typename..._XDR_ARGS> auto
1610  PMAPPROC_CALLIT(_XDR_ARGS &&..._xdr_args) ->
1611  decltype(_xdr_invoker_->template invoke<PMAPPROC_CALLIT_t,
1612  call_args>(
1613  std::forward<_XDR_ARGS>(_xdr_args)...)) {
1614  return _xdr_invoker_->template invoke<PMAPPROC_CALLIT_t,
1615  call_args>(
1616  std::forward<_XDR_ARGS>(_xdr_args)...);
1617  }
1618  };
1619 };
1620 
1621 }
1622 
1623 #endif // !__XDR_XDRPP_RPCB_PROT_HH_INCLUDED__
xdr::RPCBVERS4::RPCBPROC_GETTIME_t
Definition: rpcb_prot.hh:959
xdr::PMAP_VERS::PMAPPROC_GETPORT_t
Definition: rpcb_prot.hh:1485
xdr::RPCBVERS::RPCBPROC3_SET_t
Definition: rpcb_prot.hh:631
xdr::RPCBVERS4::RPCBPROC_BCAST_t
Definition: rpcb_prot.hh:943
types.h
Type definitions for xdrc compiler output.
xdr::xdr_void
std::tuple<> xdr_void
Placehoder type representing void values marshaled as 0 bytes.
Definition: types.h:812
xdr::RPCBVERS4::RPCBPROC_UADDR2TADDR_t
Definition: rpcb_prot.hh:975
xdr::rpcb_rmtcallres
Definition: rpcb_prot.hh:180
xdr::RPCBVERS4::RPCBPROC_GETADDR_t
Definition: rpcb_prot.hh:911
xdr::RPCBVERS4::_xdr_client
Definition: rpcb_prot.hh:1114
xdr::RPCBVERS4::RPCBPROC_GETVERSADDR_t
Definition: rpcb_prot.hh:1007
xdr::RPCBVERS::RPCBPROC3_TADDR2UADDR_t
Definition: rpcb_prot.hh:743
xdr::call_result
A unique_ptr to a call result, or NULL if the call failed (in which case message returns an error mes...
Definition: arpc.h:16
xdr::PMAP_VERS::PMAPPROC_SET_t
Definition: rpcb_prot.hh:1453
xdr
Most of the xdrpp library is encapsulated in the xdr namespace.
Definition: arpc.cc:4
xdr::pmaplist_entry
Definition: rpcb_prot.hh:1295
xdr::xstring
A string with a maximum length (returned by xstring::max_size()).
Definition: types.h:473
xdr::rp__list
Definition: rpcb_prot.hh:82
xdr::RPCBVERS4::RPCBPROC_UNSET_t
Definition: rpcb_prot.hh:895
xdr::RPCBVERS::RPCBPROC3_CALLIT_t
Definition: rpcb_prot.hh:695
xdr::RPCBVERS4::RPCBPROC_GETSTAT_t
Definition: rpcb_prot.hh:1055
xdr::PMAP_VERS::_xdr_client
Definition: rpcb_prot.hh:1558
xdr::pointer
Optional data (represented with pointer notation in XDR source).
Definition: types.h:536
xdr::PMAP_VERS
Definition: rpcb_prot.hh:1431
xdr::rpcb_entry_list
Definition: rpcb_prot.hh:286
xdr::RPCBVERS::RPCBPROC3_UNSET_t
Definition: rpcb_prot.hh:647
xdr::rpcb_rmtcallargs
Definition: rpcb_prot.hh:122
xdr::RPCBVERS::RPCBPROC3_UADDR2TADDR_t
Definition: rpcb_prot.hh:727
xdr::RPCBVERS4::RPCBPROC_DUMP_t
Definition: rpcb_prot.hh:927
xdr::call_args
Definition: rpcb_prot.hh:1335
xdr::rpcb_entry
Definition: rpcb_prot.hh:218
xdr::xdr_traits
Metadata for all marshalable XDR types.
Definition: types.h:146
xdr::validate
void validate(const T &t)
If this function template is specialized, it provides a means of placing extra restrictions on XDR da...
Definition: types.h:113
xdr::RPCBVERS::RPCBPROC3_DUMP_t
Definition: rpcb_prot.hh:679
xdr::PMAP_VERS::PMAPPROC_DUMP_t
Definition: rpcb_prot.hh:1501
xdr::rpcbs_addrlist
Definition: rpcb_prot.hh:335
xdr::RPCBVERS::RPCBPROC3_GETTIME_t
Definition: rpcb_prot.hh:711
xdr::rpcb_stat
Definition: rpcb_prot.hh:515
xdr::RPCBVERS4::RPCBPROC_TADDR2UADDR_t
Definition: rpcb_prot.hh:991
xdr::RPCBVERS4::RPCBPROC_GETADDRLIST_t
Definition: rpcb_prot.hh:1039
xdr::PMAP_VERS::PMAPPROC_NULL_t
Definition: rpcb_prot.hh:1437
xdr::rpcbs_rmtcalllist
Definition: rpcb_prot.hh:413
xdr::RPCBVERS4::RPCBPROC_INDIRECT_t
Definition: rpcb_prot.hh:1023
xdr::PMAP_VERS::PMAPPROC_UNSET_t
Definition: rpcb_prot.hh:1469
xdr::xdr_struct_base
Definition: types.h:640
xdr::PMAP_VERS::PMAPPROC_CALLIT_t
Definition: rpcb_prot.hh:1517
xdr::RPCBVERS::_xdr_client
Definition: rpcb_prot.hh:790
xdr::RPCBVERS::RPCBPROC3_GETADDR_t
Definition: rpcb_prot.hh:663
xdr::RPCBVERS4::RPCBPROC_SET_t
Definition: rpcb_prot.hh:879
Generated on Sun Sep 24 2017 21:38:49 for xdrpp by   doxygen 1.8.13