lci_binding_post.hpp

Go to the documentation of this file.

 
// Copyright (c) 2025 The LCI Project Authors
// SPDX-License-Identifier: NCSA
 
// clang-format off
// This file is generated by generate_binding.py
#ifndef LCI_BINDING_POST_HPP_
#define LCI_BINDING_POST_HPP_
 
namespace lci {
 

 
class alloc_runtime_x {
 public:
  // args declaration
  option_t<size_t> m_packet_return_threshold ;
  option_t<int> m_imm_nbits_tag ;
  option_t<int> m_imm_nbits_rcomp ;
  option_t<attr_rdv_protocol_t> m_rdv_protocol ;
  option_t<bool> m_alloc_default_device ;
  option_t<bool> m_alloc_default_packet_pool ;
  option_t<bool> m_alloc_default_matching_engine ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<std::string> m_device_name ;
 
  // constructor
  alloc_runtime_x() {}
 
  // setter
  inline alloc_runtime_x&& packet_return_threshold(size_t packet_return_threshold_in) { m_packet_return_threshold = packet_return_threshold_in; return std::move(*this); }
  inline alloc_runtime_x&& imm_nbits_tag(int imm_nbits_tag_in) { m_imm_nbits_tag = imm_nbits_tag_in; return std::move(*this); }
  inline alloc_runtime_x&& imm_nbits_rcomp(int imm_nbits_rcomp_in) { m_imm_nbits_rcomp = imm_nbits_rcomp_in; return std::move(*this); }
  inline alloc_runtime_x&& rdv_protocol(attr_rdv_protocol_t rdv_protocol_in) { m_rdv_protocol = rdv_protocol_in; return std::move(*this); }
  inline alloc_runtime_x&& alloc_default_device(bool alloc_default_device_in) { m_alloc_default_device = alloc_default_device_in; return std::move(*this); }
  inline alloc_runtime_x&& alloc_default_packet_pool(bool alloc_default_packet_pool_in) { m_alloc_default_packet_pool = alloc_default_packet_pool_in; return std::move(*this); }
  inline alloc_runtime_x&& alloc_default_matching_engine(bool alloc_default_matching_engine_in) { m_alloc_default_matching_engine = alloc_default_matching_engine_in; return std::move(*this); }
  inline alloc_runtime_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_runtime_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_runtime_x&& device_name(std::string device_name_in) { m_device_name = device_name_in; return std::move(*this); }
 
  runtime_t call_impl(size_t packet_return_threshold, int imm_nbits_tag, int imm_nbits_rcomp, attr_rdv_protocol_t rdv_protocol, bool alloc_default_device, bool alloc_default_packet_pool, bool alloc_default_matching_engine, const char* name, void* user_context, std::string device_name) const;
  runtime_t call() const;
  inline runtime_t operator()() const { return call(); }
};
 
inline runtime_t alloc_runtime() {
  return alloc_runtime_x().call();
}
 

 
class free_runtime_x {
 public:
  // args declaration
  runtime_t* m_runtime;
 
  // constructor
  free_runtime_x(runtime_t* runtime_in) : m_runtime(runtime_in) {}
 
  // setter
  inline free_runtime_x&& runtime(runtime_t* runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(runtime_t* runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_runtime(runtime_t* runtime_in) {
  return free_runtime_x(runtime_in).call();
}
 

 
class g_runtime_init_x {
 public:
  // args declaration
  option_t<size_t> m_packet_return_threshold ;
  option_t<int> m_imm_nbits_tag ;
  option_t<int> m_imm_nbits_rcomp ;
  option_t<attr_rdv_protocol_t> m_rdv_protocol ;
  option_t<bool> m_alloc_default_device ;
  option_t<bool> m_alloc_default_packet_pool ;
  option_t<bool> m_alloc_default_matching_engine ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<std::string> m_device_name ;
 
  // constructor
  g_runtime_init_x() {}
 
  // setter
  inline g_runtime_init_x&& packet_return_threshold(size_t packet_return_threshold_in) { m_packet_return_threshold = packet_return_threshold_in; return std::move(*this); }
  inline g_runtime_init_x&& imm_nbits_tag(int imm_nbits_tag_in) { m_imm_nbits_tag = imm_nbits_tag_in; return std::move(*this); }
  inline g_runtime_init_x&& imm_nbits_rcomp(int imm_nbits_rcomp_in) { m_imm_nbits_rcomp = imm_nbits_rcomp_in; return std::move(*this); }
  inline g_runtime_init_x&& rdv_protocol(attr_rdv_protocol_t rdv_protocol_in) { m_rdv_protocol = rdv_protocol_in; return std::move(*this); }
  inline g_runtime_init_x&& alloc_default_device(bool alloc_default_device_in) { m_alloc_default_device = alloc_default_device_in; return std::move(*this); }
  inline g_runtime_init_x&& alloc_default_packet_pool(bool alloc_default_packet_pool_in) { m_alloc_default_packet_pool = alloc_default_packet_pool_in; return std::move(*this); }
  inline g_runtime_init_x&& alloc_default_matching_engine(bool alloc_default_matching_engine_in) { m_alloc_default_matching_engine = alloc_default_matching_engine_in; return std::move(*this); }
  inline g_runtime_init_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline g_runtime_init_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline g_runtime_init_x&& device_name(std::string device_name_in) { m_device_name = device_name_in; return std::move(*this); }
 
  runtime_t call_impl(size_t packet_return_threshold, int imm_nbits_tag, int imm_nbits_rcomp, attr_rdv_protocol_t rdv_protocol, bool alloc_default_device, bool alloc_default_packet_pool, bool alloc_default_matching_engine, const char* name, void* user_context, std::string device_name) const;
  runtime_t call() const;
  inline runtime_t operator()() const { return call(); }
};
 
inline runtime_t g_runtime_init() {
  return g_runtime_init_x().call();
}
 

 
class g_runtime_fina_x {
 public:
  // args declaration
 
  // constructor
  g_runtime_fina_x() {}
 
  // setter
 
  void call_impl() const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void g_runtime_fina() {
  return g_runtime_fina_x().call();
}
 

 
class get_g_runtime_x {
 public:
  // args declaration
 
  // constructor
  get_g_runtime_x() {}
 
  // setter
 
  runtime_t call_impl() const;
  runtime_t call() const;
  inline runtime_t operator()() const { return call(); }
};
 
inline runtime_t get_g_runtime() {
  return get_g_runtime_x().call();
}
 

 
class alloc_packet_pool_x {
 public:
  // args declaration
  option_t<size_t> m_packet_size ;
  option_t<size_t> m_npackets ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  alloc_packet_pool_x() {}
 
  // setter
  inline alloc_packet_pool_x&& packet_size(size_t packet_size_in) { m_packet_size = packet_size_in; return std::move(*this); }
  inline alloc_packet_pool_x&& npackets(size_t npackets_in) { m_npackets = npackets_in; return std::move(*this); }
  inline alloc_packet_pool_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_packet_pool_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_packet_pool_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  packet_pool_t call_impl(size_t packet_size, size_t npackets, const char* name, void* user_context, runtime_t runtime) const;
  packet_pool_t call() const;
  inline packet_pool_t operator()() const { return call(); }
};
 
inline packet_pool_t alloc_packet_pool() {
  return alloc_packet_pool_x().call();
}
 

 
class free_packet_pool_x {
 public:
  // args declaration
  packet_pool_t* m_packet_pool;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  free_packet_pool_x(packet_pool_t* packet_pool_in) : m_packet_pool(packet_pool_in) {}
 
  // setter
  inline free_packet_pool_x&& packet_pool(packet_pool_t* packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline free_packet_pool_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(packet_pool_t* packet_pool, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_packet_pool(packet_pool_t* packet_pool_in) {
  return free_packet_pool_x(packet_pool_in).call();
}
 

 
class register_packet_pool_x {
 public:
  // args declaration
  packet_pool_t m_packet_pool;
  device_t m_device;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  register_packet_pool_x(packet_pool_t packet_pool_in, device_t device_in) : m_packet_pool(packet_pool_in), m_device(device_in) {}
 
  // setter
  inline register_packet_pool_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline register_packet_pool_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline register_packet_pool_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(packet_pool_t packet_pool, device_t device, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void register_packet_pool(packet_pool_t packet_pool_in, device_t device_in) {
  return register_packet_pool_x(packet_pool_in, device_in).call();
}
 

 
class deregister_packet_pool_x {
 public:
  // args declaration
  packet_pool_t m_packet_pool;
  device_t m_device;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  deregister_packet_pool_x(packet_pool_t packet_pool_in, device_t device_in) : m_packet_pool(packet_pool_in), m_device(device_in) {}
 
  // setter
  inline deregister_packet_pool_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline deregister_packet_pool_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline deregister_packet_pool_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(packet_pool_t packet_pool, device_t device, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void deregister_packet_pool(packet_pool_t packet_pool_in, device_t device_in) {
  return deregister_packet_pool_x(packet_pool_in, device_in).call();
}
 

 
class get_upacket_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<packet_pool_t> m_packet_pool ;
 
  // constructor
  get_upacket_x() {}
 
  // setter
  inline get_upacket_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline get_upacket_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
 
  void* call_impl(runtime_t runtime, packet_pool_t packet_pool) const;
  void* call() const;
  inline void* operator()() const { return call(); }
};
 
inline void* get_upacket() {
  return get_upacket_x().call();
}
 

 
class put_upacket_x {
 public:
  // args declaration
  void* m_packet;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  put_upacket_x(void* packet_in) : m_packet(packet_in) {}
 
  // setter
  inline put_upacket_x&& packet(void* packet_in) { m_packet = packet_in; return std::move(*this); }
  inline put_upacket_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(void* packet, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void put_upacket(void* packet_in) {
  return put_upacket_x(packet_in).call();
}
 

 
class alloc_matching_engine_x {
 public:
  // args declaration
  option_t<attr_matching_engine_type_t> m_matching_engine_type ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  alloc_matching_engine_x() {}
 
  // setter
  inline alloc_matching_engine_x&& matching_engine_type(attr_matching_engine_type_t matching_engine_type_in) { m_matching_engine_type = matching_engine_type_in; return std::move(*this); }
  inline alloc_matching_engine_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_matching_engine_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_matching_engine_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  matching_engine_t call_impl(attr_matching_engine_type_t matching_engine_type, const char* name, void* user_context, runtime_t runtime) const;
  matching_engine_t call() const;
  inline matching_engine_t operator()() const { return call(); }
};
 
inline matching_engine_t alloc_matching_engine() {
  return alloc_matching_engine_x().call();
}
 

 
class free_matching_engine_x {
 public:
  // args declaration
  matching_engine_t* m_matching_engine;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  free_matching_engine_x(matching_engine_t* matching_engine_in) : m_matching_engine(matching_engine_in) {}
 
  // setter
  inline free_matching_engine_x&& matching_engine(matching_engine_t* matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline free_matching_engine_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(matching_engine_t* matching_engine, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_matching_engine(matching_engine_t* matching_engine_in) {
  return free_matching_engine_x(matching_engine_in).call();
}
 

 
class matching_engine_insert_x {
 public:
  // args declaration
  matching_engine_t m_matching_engine;
  matching_entry_key_t m_key;
  matching_entry_val_t m_value;
  matching_entry_type_t m_entry_type;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  matching_engine_insert_x(matching_engine_t matching_engine_in, matching_entry_key_t key_in, matching_entry_val_t value_in, matching_entry_type_t entry_type_in) : m_matching_engine(matching_engine_in), m_key(key_in), m_value(value_in), m_entry_type(entry_type_in) {}
 
  // setter
  inline matching_engine_insert_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline matching_engine_insert_x&& key(matching_entry_key_t key_in) { m_key = key_in; return std::move(*this); }
  inline matching_engine_insert_x&& value(matching_entry_val_t value_in) { m_value = value_in; return std::move(*this); }
  inline matching_engine_insert_x&& entry_type(matching_entry_type_t entry_type_in) { m_entry_type = entry_type_in; return std::move(*this); }
  inline matching_engine_insert_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  matching_entry_val_t call_impl(matching_engine_t matching_engine, matching_entry_key_t key, matching_entry_val_t value, matching_entry_type_t entry_type, runtime_t runtime) const;
  matching_entry_val_t call() const;
  inline matching_entry_val_t operator()() const { return call(); }
};
 
inline matching_entry_val_t matching_engine_insert(matching_engine_t matching_engine_in, matching_entry_key_t key_in, matching_entry_val_t value_in, matching_entry_type_t entry_type_in) {
  return matching_engine_insert_x(matching_engine_in, key_in, value_in, entry_type_in).call();
}
 

 
class set_allocator_x {
 public:
  // args declaration
  allocator_base_t* m_allocator;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  set_allocator_x(allocator_base_t* allocator_in) : m_allocator(allocator_in) {}
 
  // setter
  inline set_allocator_x&& allocator(allocator_base_t* allocator_in) { m_allocator = allocator_in; return std::move(*this); }
  inline set_allocator_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(allocator_base_t* allocator, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void set_allocator(allocator_base_t* allocator_in) {
  return set_allocator_x(allocator_in).call();
}
 

 
class get_allocator_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
 
  // constructor
  get_allocator_x() {}
 
  // setter
  inline get_allocator_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  allocator_base_t* call_impl(runtime_t runtime) const;
  allocator_base_t* call() const;
  inline allocator_base_t* operator()() const { return call(); }
};
 
inline allocator_base_t* get_allocator() {
  return get_allocator_x().call();
}
 

 
class get_default_net_context_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
 
  // constructor
  get_default_net_context_x() {}
 
  // setter
  inline get_default_net_context_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  net_context_t call_impl(runtime_t runtime) const;
  net_context_t call() const;
  inline net_context_t operator()() const { return call(); }
};
 
inline net_context_t get_default_net_context() {
  return get_default_net_context_x().call();
}
 

 
class get_default_device_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
 
  // constructor
  get_default_device_x() {}
 
  // setter
  inline get_default_device_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  device_t call_impl(runtime_t runtime) const;
  device_t call() const;
  inline device_t operator()() const { return call(); }
};
 
inline device_t get_default_device() {
  return get_default_device_x().call();
}
 

 
class get_default_endpoint_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
 
  // constructor
  get_default_endpoint_x() {}
 
  // setter
  inline get_default_endpoint_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline get_default_endpoint_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  endpoint_t call_impl(runtime_t runtime, device_t device) const;
  endpoint_t call() const;
  inline endpoint_t operator()() const { return call(); }
};
 
inline endpoint_t get_default_endpoint() {
  return get_default_endpoint_x().call();
}
 

 
class get_default_packet_pool_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
 
  // constructor
  get_default_packet_pool_x() {}
 
  // setter
  inline get_default_packet_pool_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  packet_pool_t call_impl(runtime_t runtime) const;
  packet_pool_t call() const;
  inline packet_pool_t operator()() const { return call(); }
};
 
inline packet_pool_t get_default_packet_pool() {
  return get_default_packet_pool_x().call();
}
 

 
class get_default_matching_engine_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
 
  // constructor
  get_default_matching_engine_x() {}
 
  // setter
  inline get_default_matching_engine_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  matching_engine_t call_impl(runtime_t runtime) const;
  matching_engine_t call() const;
  inline matching_engine_t operator()() const { return call(); }
};
 
inline matching_engine_t get_default_matching_engine() {
  return get_default_matching_engine_x().call();
}
 

 
class get_max_bcopy_size_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<packet_pool_t> m_packet_pool ;
 
  // constructor
  get_max_bcopy_size_x() {}
 
  // setter
  inline get_max_bcopy_size_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline get_max_bcopy_size_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
 
  size_t call_impl(runtime_t runtime, packet_pool_t packet_pool) const;
  size_t call() const;
  inline size_t operator()() const { return call(); }
};
 
inline size_t get_max_bcopy_size() {
  return get_max_bcopy_size_x().call();
}
 

 
class alloc_net_context_x {
 public:
  // args declaration
  option_t<attr_backend_t> m_backend ;
  option_t<std::string> m_ofi_provider_name ;
  option_t<size_t> m_max_msg_size ;
  option_t<size_t> m_max_inject_size ;
  option_t<int> m_ibv_gid_idx ;
  option_t<bool> m_ibv_force_gid_auto_select ;
  option_t<std::string> m_device_name ;
  option_t<attr_ibv_odp_strategy_t> m_ibv_odp_strategy ;
  option_t<attr_ibv_prefetch_strategy_t> m_ibv_prefetch_strategy ;
  option_t<bool> m_use_dmabuf ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  alloc_net_context_x() {}
 
  // setter
  inline alloc_net_context_x&& backend(attr_backend_t backend_in) { m_backend = backend_in; return std::move(*this); }
  inline alloc_net_context_x&& ofi_provider_name(std::string ofi_provider_name_in) { m_ofi_provider_name = ofi_provider_name_in; return std::move(*this); }
  inline alloc_net_context_x&& max_msg_size(size_t max_msg_size_in) { m_max_msg_size = max_msg_size_in; return std::move(*this); }
  inline alloc_net_context_x&& max_inject_size(size_t max_inject_size_in) { m_max_inject_size = max_inject_size_in; return std::move(*this); }
  inline alloc_net_context_x&& ibv_gid_idx(int ibv_gid_idx_in) { m_ibv_gid_idx = ibv_gid_idx_in; return std::move(*this); }
  inline alloc_net_context_x&& ibv_force_gid_auto_select(bool ibv_force_gid_auto_select_in) { m_ibv_force_gid_auto_select = ibv_force_gid_auto_select_in; return std::move(*this); }
  inline alloc_net_context_x&& device_name(std::string device_name_in) { m_device_name = device_name_in; return std::move(*this); }
  inline alloc_net_context_x&& ibv_odp_strategy(attr_ibv_odp_strategy_t ibv_odp_strategy_in) { m_ibv_odp_strategy = ibv_odp_strategy_in; return std::move(*this); }
  inline alloc_net_context_x&& ibv_prefetch_strategy(attr_ibv_prefetch_strategy_t ibv_prefetch_strategy_in) { m_ibv_prefetch_strategy = ibv_prefetch_strategy_in; return std::move(*this); }
  inline alloc_net_context_x&& use_dmabuf(bool use_dmabuf_in) { m_use_dmabuf = use_dmabuf_in; return std::move(*this); }
  inline alloc_net_context_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_net_context_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_net_context_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  net_context_t call_impl(attr_backend_t backend, std::string ofi_provider_name, size_t max_msg_size, size_t max_inject_size, int ibv_gid_idx, bool ibv_force_gid_auto_select, std::string device_name, attr_ibv_odp_strategy_t ibv_odp_strategy, attr_ibv_prefetch_strategy_t ibv_prefetch_strategy, bool use_dmabuf, const char* name, void* user_context, runtime_t runtime) const;
  net_context_t call() const;
  inline net_context_t operator()() const { return call(); }
};
 
inline net_context_t alloc_net_context() {
  return alloc_net_context_x().call();
}
 

 
class free_net_context_x {
 public:
  // args declaration
  net_context_t* m_net_context;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  free_net_context_x(net_context_t* net_context_in) : m_net_context(net_context_in) {}
 
  // setter
  inline free_net_context_x&& net_context(net_context_t* net_context_in) { m_net_context = net_context_in; return std::move(*this); }
  inline free_net_context_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(net_context_t* net_context, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_net_context(net_context_t* net_context_in) {
  return free_net_context_x(net_context_in).call();
}
 

 
class alloc_device_x {
 public:
  // args declaration
  option_t<size_t> m_net_max_sends ;
  option_t<size_t> m_net_max_recvs ;
  option_t<size_t> m_net_max_cqes ;
  option_t<double> m_net_send_reserved_pct ;
  option_t<uint64_t> m_ofi_lock_mode ;
  option_t<bool> m_alloc_default_endpoint ;
  option_t<bool> m_alloc_progress_endpoint ;
  option_t<bool> m_use_reg_cache ;
  option_t<attr_ibv_td_strategy_t> m_ibv_td_strategy ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<runtime_t> m_runtime ;
  option_t<net_context_t> m_net_context ;
  option_t<packet_pool_t> m_packet_pool ;
 
  // constructor
  alloc_device_x() {}
 
  // setter
  inline alloc_device_x&& net_max_sends(size_t net_max_sends_in) { m_net_max_sends = net_max_sends_in; return std::move(*this); }
  inline alloc_device_x&& net_max_recvs(size_t net_max_recvs_in) { m_net_max_recvs = net_max_recvs_in; return std::move(*this); }
  inline alloc_device_x&& net_max_cqes(size_t net_max_cqes_in) { m_net_max_cqes = net_max_cqes_in; return std::move(*this); }
  inline alloc_device_x&& net_send_reserved_pct(double net_send_reserved_pct_in) { m_net_send_reserved_pct = net_send_reserved_pct_in; return std::move(*this); }
  inline alloc_device_x&& ofi_lock_mode(uint64_t ofi_lock_mode_in) { m_ofi_lock_mode = ofi_lock_mode_in; return std::move(*this); }
  inline alloc_device_x&& alloc_default_endpoint(bool alloc_default_endpoint_in) { m_alloc_default_endpoint = alloc_default_endpoint_in; return std::move(*this); }
  inline alloc_device_x&& alloc_progress_endpoint(bool alloc_progress_endpoint_in) { m_alloc_progress_endpoint = alloc_progress_endpoint_in; return std::move(*this); }
  inline alloc_device_x&& use_reg_cache(bool use_reg_cache_in) { m_use_reg_cache = use_reg_cache_in; return std::move(*this); }
  inline alloc_device_x&& ibv_td_strategy(attr_ibv_td_strategy_t ibv_td_strategy_in) { m_ibv_td_strategy = ibv_td_strategy_in; return std::move(*this); }
  inline alloc_device_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_device_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_device_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alloc_device_x&& net_context(net_context_t net_context_in) { m_net_context = net_context_in; return std::move(*this); }
  inline alloc_device_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
 
  device_t call_impl(size_t net_max_sends, size_t net_max_recvs, size_t net_max_cqes, double net_send_reserved_pct, uint64_t ofi_lock_mode, bool alloc_default_endpoint, bool alloc_progress_endpoint, bool use_reg_cache, attr_ibv_td_strategy_t ibv_td_strategy, const char* name, void* user_context, runtime_t runtime, net_context_t net_context, packet_pool_t packet_pool) const;
  device_t call() const;
  inline device_t operator()() const { return call(); }
};
 
inline device_t alloc_device() {
  return alloc_device_x().call();
}
 

 
class free_device_x {
 public:
  // args declaration
  device_t* m_device;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  free_device_x(device_t* device_in) : m_device(device_in) {}
 
  // setter
  inline free_device_x&& device(device_t* device_in) { m_device = device_in; return std::move(*this); }
  inline free_device_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(device_t* device, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_device(device_t* device_in) {
  return free_device_x(device_in).call();
}
 

 
class register_memory_x {
 public:
  // args declaration
  void* m_address;
  size_t m_size;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
 
  // constructor
  register_memory_x(void* address_in, size_t size_in) : m_address(address_in), m_size(size_in) {}
 
  // setter
  inline register_memory_x&& address(void* address_in) { m_address = address_in; return std::move(*this); }
  inline register_memory_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline register_memory_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline register_memory_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  mr_t call_impl(void* address, size_t size, runtime_t runtime, device_t device) const;
  mr_t call() const;
  inline mr_t operator()() const { return call(); }
};
 
inline mr_t register_memory(void* address_in, size_t size_in) {
  return register_memory_x(address_in, size_in).call();
}
 

 
class deregister_memory_x {
 public:
  // args declaration
  mr_t* m_mr;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  deregister_memory_x(mr_t* mr_in) : m_mr(mr_in) {}
 
  // setter
  inline deregister_memory_x&& mr(mr_t* mr_in) { m_mr = mr_in; return std::move(*this); }
  inline deregister_memory_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(mr_t* mr, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void deregister_memory(mr_t* mr_in) {
  return deregister_memory_x(mr_in).call();
}
 

 
class get_rmr_x {
 public:
  // args declaration
  mr_t m_mr;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  get_rmr_x(mr_t mr_in) : m_mr(mr_in) {}
 
  // setter
  inline get_rmr_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline get_rmr_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  rmr_t call_impl(mr_t mr, runtime_t runtime) const;
  rmr_t call() const;
  inline rmr_t operator()() const { return call(); }
};
 
inline rmr_t get_rmr(mr_t mr_in) {
  return get_rmr_x(mr_in).call();
}
 

 
class alloc_endpoint_x {
 public:
  // args declaration
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
 
  // constructor
  alloc_endpoint_x() {}
 
  // setter
  inline alloc_endpoint_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_endpoint_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_endpoint_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alloc_endpoint_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  endpoint_t call_impl(const char* name, void* user_context, runtime_t runtime, device_t device) const;
  endpoint_t call() const;
  inline endpoint_t operator()() const { return call(); }
};
 
inline endpoint_t alloc_endpoint() {
  return alloc_endpoint_x().call();
}
 

 
class free_endpoint_x {
 public:
  // args declaration
  endpoint_t* m_endpoint;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  free_endpoint_x(endpoint_t* endpoint_in) : m_endpoint(endpoint_in) {}
 
  // setter
  inline free_endpoint_x&& endpoint(endpoint_t* endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline free_endpoint_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(endpoint_t* endpoint, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_endpoint(endpoint_t* endpoint_in) {
  return free_endpoint_x(endpoint_in).call();
}
 

 
class net_poll_cq_x {
 public:
  // args declaration
  size_t m_max_polls;
  net_status_t* m_statuses;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
 
  // constructor
  net_poll_cq_x(size_t max_polls_in, net_status_t* statuses_in) : m_max_polls(max_polls_in), m_statuses(statuses_in) {}
 
  // setter
  inline net_poll_cq_x&& max_polls(size_t max_polls_in) { m_max_polls = max_polls_in; return std::move(*this); }
  inline net_poll_cq_x&& statuses(net_status_t* statuses_in) { m_statuses = statuses_in; return std::move(*this); }
  inline net_poll_cq_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_poll_cq_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  size_t call_impl(size_t max_polls, net_status_t* statuses, runtime_t runtime, device_t device) const;
  size_t call() const;
  inline size_t operator()() const { return call(); }
};
 
inline size_t net_poll_cq(size_t max_polls_in, net_status_t* statuses_in) {
  return net_poll_cq_x(max_polls_in, statuses_in).call();
}
 

 
class net_post_recv_x {
 public:
  // args declaration
  void* m_buffer;
  size_t m_size;
  mr_t m_mr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_recv_x(void* buffer_in, size_t size_in, mr_t mr_in) : m_buffer(buffer_in), m_size(size_in), m_mr(mr_in) {}
 
  // setter
  inline net_post_recv_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_recv_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_recv_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline net_post_recv_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_recv_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_recv_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(void* buffer, size_t size, mr_t mr, runtime_t runtime, device_t device, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_recv(void* buffer_in, size_t size_in, mr_t mr_in) {
  return net_post_recv_x(buffer_in, size_in, mr_in).call();
}
 

 
class net_post_sends_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<net_imm_data_t> m_imm_data ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_sends_x(int rank_in, void* buffer_in, size_t size_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in) {}
 
  // setter
  inline net_post_sends_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_sends_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_sends_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_sends_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_sends_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_sends_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_sends_x&& imm_data(net_imm_data_t imm_data_in) { m_imm_data = imm_data_in; return std::move(*this); }
  inline net_post_sends_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, runtime_t runtime, device_t device, endpoint_t endpoint, net_imm_data_t imm_data, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_sends(int rank_in, void* buffer_in, size_t size_in) {
  return net_post_sends_x(rank_in, buffer_in, size_in).call();
}
 

 
class net_post_send_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  mr_t m_mr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<net_imm_data_t> m_imm_data ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_send_x(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in), m_mr(mr_in) {}
 
  // setter
  inline net_post_send_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_send_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_send_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_send_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline net_post_send_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_send_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_send_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_send_x&& imm_data(net_imm_data_t imm_data_in) { m_imm_data = imm_data_in; return std::move(*this); }
  inline net_post_send_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, mr_t mr, runtime_t runtime, device_t device, endpoint_t endpoint, net_imm_data_t imm_data, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_send(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in) {
  return net_post_send_x(rank_in, buffer_in, size_in, mr_in).call();
}
 

 
class net_post_puts_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  uint64_t m_offset;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_puts_x(int rank_in, void* buffer_in, size_t size_in, uint64_t offset_in, rmr_t rmr_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in), m_offset(offset_in), m_rmr(rmr_in) {}
 
  // setter
  inline net_post_puts_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_puts_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_puts_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_puts_x&& offset(uint64_t offset_in) { m_offset = offset_in; return std::move(*this); }
  inline net_post_puts_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline net_post_puts_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_puts_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_puts_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_puts_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, uint64_t offset, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_puts(int rank_in, void* buffer_in, size_t size_in, uint64_t offset_in, rmr_t rmr_in) {
  return net_post_puts_x(rank_in, buffer_in, size_in, offset_in, rmr_in).call();
}
 

 
class net_post_put_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  mr_t m_mr;
  uint64_t m_offset;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_put_x(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in, uint64_t offset_in, rmr_t rmr_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in), m_mr(mr_in), m_offset(offset_in), m_rmr(rmr_in) {}
 
  // setter
  inline net_post_put_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_put_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_put_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_put_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline net_post_put_x&& offset(uint64_t offset_in) { m_offset = offset_in; return std::move(*this); }
  inline net_post_put_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline net_post_put_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_put_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_put_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_put_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, mr_t mr, uint64_t offset, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_put(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in, uint64_t offset_in, rmr_t rmr_in) {
  return net_post_put_x(rank_in, buffer_in, size_in, mr_in, offset_in, rmr_in).call();
}
 

 
class net_post_putImms_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  uint64_t m_offset;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<net_imm_data_t> m_imm_data ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_putImms_x(int rank_in, void* buffer_in, size_t size_in, uint64_t offset_in, rmr_t rmr_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in), m_offset(offset_in), m_rmr(rmr_in) {}
 
  // setter
  inline net_post_putImms_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_putImms_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_putImms_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_putImms_x&& offset(uint64_t offset_in) { m_offset = offset_in; return std::move(*this); }
  inline net_post_putImms_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline net_post_putImms_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_putImms_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_putImms_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_putImms_x&& imm_data(net_imm_data_t imm_data_in) { m_imm_data = imm_data_in; return std::move(*this); }
  inline net_post_putImms_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, uint64_t offset, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, net_imm_data_t imm_data, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_putImms(int rank_in, void* buffer_in, size_t size_in, uint64_t offset_in, rmr_t rmr_in) {
  return net_post_putImms_x(rank_in, buffer_in, size_in, offset_in, rmr_in).call();
}
 

 
class net_post_putImm_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  mr_t m_mr;
  uint64_t m_offset;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<net_imm_data_t> m_imm_data ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_putImm_x(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in, uint64_t offset_in, rmr_t rmr_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in), m_mr(mr_in), m_offset(offset_in), m_rmr(rmr_in) {}
 
  // setter
  inline net_post_putImm_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_putImm_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_putImm_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_putImm_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline net_post_putImm_x&& offset(uint64_t offset_in) { m_offset = offset_in; return std::move(*this); }
  inline net_post_putImm_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline net_post_putImm_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_putImm_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_putImm_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_putImm_x&& imm_data(net_imm_data_t imm_data_in) { m_imm_data = imm_data_in; return std::move(*this); }
  inline net_post_putImm_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, mr_t mr, uint64_t offset, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, net_imm_data_t imm_data, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_putImm(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in, uint64_t offset_in, rmr_t rmr_in) {
  return net_post_putImm_x(rank_in, buffer_in, size_in, mr_in, offset_in, rmr_in).call();
}
 

 
class net_post_get_x {
 public:
  // args declaration
  int m_rank;
  void* m_buffer;
  size_t m_size;
  mr_t m_mr;
  uint64_t m_offset;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<void*> m_user_context ;
 
  // constructor
  net_post_get_x(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in, uint64_t offset_in, rmr_t rmr_in) : m_rank(rank_in), m_buffer(buffer_in), m_size(size_in), m_mr(mr_in), m_offset(offset_in), m_rmr(rmr_in) {}
 
  // setter
  inline net_post_get_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline net_post_get_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline net_post_get_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline net_post_get_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline net_post_get_x&& offset(uint64_t offset_in) { m_offset = offset_in; return std::move(*this); }
  inline net_post_get_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline net_post_get_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline net_post_get_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline net_post_get_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline net_post_get_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  error_t call_impl(int rank, void* buffer, size_t size, mr_t mr, uint64_t offset, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, void* user_context) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t net_post_get(int rank_in, void* buffer_in, size_t size_in, mr_t mr_in, uint64_t offset_in, rmr_t rmr_in) {
  return net_post_get_x(rank_in, buffer_in, size_in, mr_in, offset_in, rmr_in).call();
}
 

 
class barrier_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<comp_t> m_comp ;
 
  // constructor
  barrier_x() {}
 
  // setter
  inline barrier_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline barrier_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline barrier_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline barrier_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline barrier_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline barrier_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
 
  void call_impl(runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine, comp_semantic_t comp_semantic, comp_t comp) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void barrier() {
  return barrier_x().call();
}
 

 
class broadcast_x {
 public:
  // args declaration
  void* m_buffer;
  size_t m_size;
  int m_root;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_t> m_comp ;
  option_t<broadcast_algorithm_t> m_algorithm ;
  option_t<int> m_ring_nsteps ;
 
  // constructor
  broadcast_x(void* buffer_in, size_t size_in, int root_in) : m_buffer(buffer_in), m_size(size_in), m_root(root_in) {}
 
  // setter
  inline broadcast_x&& buffer(void* buffer_in) { m_buffer = buffer_in; return std::move(*this); }
  inline broadcast_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline broadcast_x&& root(int root_in) { m_root = root_in; return std::move(*this); }
  inline broadcast_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline broadcast_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline broadcast_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline broadcast_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline broadcast_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline broadcast_x&& algorithm(broadcast_algorithm_t algorithm_in) { m_algorithm = algorithm_in; return std::move(*this); }
  inline broadcast_x&& ring_nsteps(int ring_nsteps_in) { m_ring_nsteps = ring_nsteps_in; return std::move(*this); }
 
  void call_impl(void* buffer, size_t size, int root, runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine, comp_t comp, broadcast_algorithm_t algorithm, int ring_nsteps) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void broadcast(void* buffer_in, size_t size_in, int root_in) {
  return broadcast_x(buffer_in, size_in, root_in).call();
}
 

 
class reduce_x {
 public:
  // args declaration
  const void* m_sendbuf;
  void* m_recvbuf;
  size_t m_count;
  size_t m_item_size;
  reduce_op_t m_op;
  int m_root;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
 
  // constructor
  reduce_x(const void* sendbuf_in, void* recvbuf_in, size_t count_in, size_t item_size_in, reduce_op_t op_in, int root_in) : m_sendbuf(sendbuf_in), m_recvbuf(recvbuf_in), m_count(count_in), m_item_size(item_size_in), m_op(op_in), m_root(root_in) {}
 
  // setter
  inline reduce_x&& sendbuf(const void* sendbuf_in) { m_sendbuf = sendbuf_in; return std::move(*this); }
  inline reduce_x&& recvbuf(void* recvbuf_in) { m_recvbuf = recvbuf_in; return std::move(*this); }
  inline reduce_x&& count(size_t count_in) { m_count = count_in; return std::move(*this); }
  inline reduce_x&& item_size(size_t item_size_in) { m_item_size = item_size_in; return std::move(*this); }
  inline reduce_x&& op(reduce_op_t op_in) { m_op = op_in; return std::move(*this); }
  inline reduce_x&& root(int root_in) { m_root = root_in; return std::move(*this); }
  inline reduce_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline reduce_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline reduce_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline reduce_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
 
  void call_impl(const void* sendbuf, void* recvbuf, size_t count, size_t item_size, reduce_op_t op, int root, runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void reduce(const void* sendbuf_in, void* recvbuf_in, size_t count_in, size_t item_size_in, reduce_op_t op_in, int root_in) {
  return reduce_x(sendbuf_in, recvbuf_in, count_in, item_size_in, op_in, root_in).call();
}
 

 
class reduce_scatter_x {
 public:
  // args declaration
  const void* m_sendbuf;
  void* m_recvbuf;
  size_t m_recvcount;
  size_t m_item_size;
  reduce_op_t m_op;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_t> m_comp ;
  option_t<reduce_scatter_algorithm_t> m_algorithm ;
  option_t<int> m_ring_nsteps ;
 
  // constructor
  reduce_scatter_x(const void* sendbuf_in, void* recvbuf_in, size_t recvcount_in, size_t item_size_in, reduce_op_t op_in) : m_sendbuf(sendbuf_in), m_recvbuf(recvbuf_in), m_recvcount(recvcount_in), m_item_size(item_size_in), m_op(op_in) {}
 
  // setter
  inline reduce_scatter_x&& sendbuf(const void* sendbuf_in) { m_sendbuf = sendbuf_in; return std::move(*this); }
  inline reduce_scatter_x&& recvbuf(void* recvbuf_in) { m_recvbuf = recvbuf_in; return std::move(*this); }
  inline reduce_scatter_x&& recvcount(size_t recvcount_in) { m_recvcount = recvcount_in; return std::move(*this); }
  inline reduce_scatter_x&& item_size(size_t item_size_in) { m_item_size = item_size_in; return std::move(*this); }
  inline reduce_scatter_x&& op(reduce_op_t op_in) { m_op = op_in; return std::move(*this); }
  inline reduce_scatter_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline reduce_scatter_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline reduce_scatter_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline reduce_scatter_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline reduce_scatter_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline reduce_scatter_x&& algorithm(reduce_scatter_algorithm_t algorithm_in) { m_algorithm = algorithm_in; return std::move(*this); }
  inline reduce_scatter_x&& ring_nsteps(int ring_nsteps_in) { m_ring_nsteps = ring_nsteps_in; return std::move(*this); }
 
  void call_impl(const void* sendbuf, void* recvbuf, size_t recvcount, size_t item_size, reduce_op_t op, runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine, comp_t comp, reduce_scatter_algorithm_t algorithm, int ring_nsteps) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void reduce_scatter(const void* sendbuf_in, void* recvbuf_in, size_t recvcount_in, size_t item_size_in, reduce_op_t op_in) {
  return reduce_scatter_x(sendbuf_in, recvbuf_in, recvcount_in, item_size_in, op_in).call();
}
 

 
class allreduce_x {
 public:
  // args declaration
  const void* m_sendbuf;
  void* m_recvbuf;
  size_t m_count;
  size_t m_item_size;
  reduce_op_t m_op;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_t> m_comp ;
  option_t<allreduce_algorithm_t> m_algorithm ;
  option_t<int> m_ring_nsteps ;
 
  // constructor
  allreduce_x(const void* sendbuf_in, void* recvbuf_in, size_t count_in, size_t item_size_in, reduce_op_t op_in) : m_sendbuf(sendbuf_in), m_recvbuf(recvbuf_in), m_count(count_in), m_item_size(item_size_in), m_op(op_in) {}
 
  // setter
  inline allreduce_x&& sendbuf(const void* sendbuf_in) { m_sendbuf = sendbuf_in; return std::move(*this); }
  inline allreduce_x&& recvbuf(void* recvbuf_in) { m_recvbuf = recvbuf_in; return std::move(*this); }
  inline allreduce_x&& count(size_t count_in) { m_count = count_in; return std::move(*this); }
  inline allreduce_x&& item_size(size_t item_size_in) { m_item_size = item_size_in; return std::move(*this); }
  inline allreduce_x&& op(reduce_op_t op_in) { m_op = op_in; return std::move(*this); }
  inline allreduce_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline allreduce_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline allreduce_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline allreduce_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline allreduce_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline allreduce_x&& algorithm(allreduce_algorithm_t algorithm_in) { m_algorithm = algorithm_in; return std::move(*this); }
  inline allreduce_x&& ring_nsteps(int ring_nsteps_in) { m_ring_nsteps = ring_nsteps_in; return std::move(*this); }
 
  void call_impl(const void* sendbuf, void* recvbuf, size_t count, size_t item_size, reduce_op_t op, runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine, comp_t comp, allreduce_algorithm_t algorithm, int ring_nsteps) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void allreduce(const void* sendbuf_in, void* recvbuf_in, size_t count_in, size_t item_size_in, reduce_op_t op_in) {
  return allreduce_x(sendbuf_in, recvbuf_in, count_in, item_size_in, op_in).call();
}
 

 
class allgather_x {
 public:
  // args declaration
  const void* m_sendbuf;
  void* m_recvbuf;
  size_t m_size;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
 
  // constructor
  allgather_x(const void* sendbuf_in, void* recvbuf_in, size_t size_in) : m_sendbuf(sendbuf_in), m_recvbuf(recvbuf_in), m_size(size_in) {}
 
  // setter
  inline allgather_x&& sendbuf(const void* sendbuf_in) { m_sendbuf = sendbuf_in; return std::move(*this); }
  inline allgather_x&& recvbuf(void* recvbuf_in) { m_recvbuf = recvbuf_in; return std::move(*this); }
  inline allgather_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline allgather_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline allgather_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline allgather_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline allgather_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
 
  void call_impl(const void* sendbuf, void* recvbuf, size_t size, runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void allgather(const void* sendbuf_in, void* recvbuf_in, size_t size_in) {
  return allgather_x(sendbuf_in, recvbuf_in, size_in).call();
}
 

 
class alltoall_x {
 public:
  // args declaration
  const void* m_sendbuf;
  void* m_recvbuf;
  size_t m_size;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_semantic_t> m_comp_semantic ;
 
  // constructor
  alltoall_x(const void* sendbuf_in, void* recvbuf_in, size_t size_in) : m_sendbuf(sendbuf_in), m_recvbuf(recvbuf_in), m_size(size_in) {}
 
  // setter
  inline alltoall_x&& sendbuf(const void* sendbuf_in) { m_sendbuf = sendbuf_in; return std::move(*this); }
  inline alltoall_x&& recvbuf(void* recvbuf_in) { m_recvbuf = recvbuf_in; return std::move(*this); }
  inline alltoall_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline alltoall_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alltoall_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline alltoall_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline alltoall_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline alltoall_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
 
  void call_impl(const void* sendbuf, void* recvbuf, size_t size, runtime_t runtime, device_t device, endpoint_t endpoint, matching_engine_t matching_engine, comp_semantic_t comp_semantic) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void alltoall(const void* sendbuf_in, void* recvbuf_in, size_t size_in) {
  return alltoall_x(sendbuf_in, recvbuf_in, size_in).call();
}
 

 
class post_comm_x {
 public:
  // args declaration
  direction_t m_direction;
  int m_rank;
  void* m_local_buffer;
  size_t m_size;
  comp_t m_local_comp;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<packet_pool_t> m_packet_pool ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<mr_t> m_mr ;
  option_t<uintptr_t> m_remote_disp ;
  option_t<rmr_t> m_rmr ;
  option_t<tag_t> m_tag ;
  option_t<rcomp_t> m_remote_comp ;
  option_t<void*> m_user_context ;
  option_t<matching_policy_t> m_matching_policy ;
  option_t<bool> m_allow_done ;
  option_t<bool> m_allow_posted ;
  option_t<bool> m_allow_retry ;
 
  // constructor
  post_comm_x(direction_t direction_in, int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in) : m_direction(direction_in), m_rank(rank_in), m_local_buffer(local_buffer_in), m_size(size_in), m_local_comp(local_comp_in) {}
 
  // setter
  inline post_comm_x&& direction(direction_t direction_in) { m_direction = direction_in; return std::move(*this); }
  inline post_comm_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline post_comm_x&& local_buffer(void* local_buffer_in) { m_local_buffer = local_buffer_in; return std::move(*this); }
  inline post_comm_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline post_comm_x&& local_comp(comp_t local_comp_in) { m_local_comp = local_comp_in; return std::move(*this); }
  inline post_comm_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline post_comm_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline post_comm_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline post_comm_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline post_comm_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline post_comm_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline post_comm_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline post_comm_x&& remote_disp(uintptr_t remote_disp_in) { m_remote_disp = remote_disp_in; return std::move(*this); }
  inline post_comm_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline post_comm_x&& tag(tag_t tag_in) { m_tag = tag_in; return std::move(*this); }
  inline post_comm_x&& remote_comp(rcomp_t remote_comp_in) { m_remote_comp = remote_comp_in; return std::move(*this); }
  inline post_comm_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline post_comm_x&& matching_policy(matching_policy_t matching_policy_in) { m_matching_policy = matching_policy_in; return std::move(*this); }
  inline post_comm_x&& allow_done(bool allow_done_in) { m_allow_done = allow_done_in; return std::move(*this); }
  inline post_comm_x&& allow_posted(bool allow_posted_in) { m_allow_posted = allow_posted_in; return std::move(*this); }
  inline post_comm_x&& allow_retry(bool allow_retry_in) { m_allow_retry = allow_retry_in; return std::move(*this); }
 
  status_t call_impl(direction_t direction, int rank, void* local_buffer, size_t size, comp_t local_comp, runtime_t runtime, device_t device, endpoint_t endpoint, packet_pool_t packet_pool, matching_engine_t matching_engine, comp_semantic_t comp_semantic, mr_t mr, uintptr_t remote_disp, rmr_t rmr, tag_t tag, rcomp_t remote_comp, void* user_context, matching_policy_t matching_policy, bool allow_done, bool allow_posted, bool allow_retry) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t post_comm(direction_t direction_in, int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in) {
  return post_comm_x(direction_in, rank_in, local_buffer_in, size_in, local_comp_in).call();
}
 

 
class post_am_x {
 public:
  // args declaration
  int m_rank;
  void* m_local_buffer;
  size_t m_size;
  comp_t m_local_comp;
  rcomp_t m_remote_comp;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<packet_pool_t> m_packet_pool ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<mr_t> m_mr ;
  option_t<tag_t> m_tag ;
  option_t<void*> m_user_context ;
  option_t<bool> m_allow_done ;
  option_t<bool> m_allow_posted ;
  option_t<bool> m_allow_retry ;
 
  // constructor
  post_am_x(int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in, rcomp_t remote_comp_in) : m_rank(rank_in), m_local_buffer(local_buffer_in), m_size(size_in), m_local_comp(local_comp_in), m_remote_comp(remote_comp_in) {}
 
  // setter
  inline post_am_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline post_am_x&& local_buffer(void* local_buffer_in) { m_local_buffer = local_buffer_in; return std::move(*this); }
  inline post_am_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline post_am_x&& local_comp(comp_t local_comp_in) { m_local_comp = local_comp_in; return std::move(*this); }
  inline post_am_x&& remote_comp(rcomp_t remote_comp_in) { m_remote_comp = remote_comp_in; return std::move(*this); }
  inline post_am_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline post_am_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline post_am_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline post_am_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline post_am_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline post_am_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline post_am_x&& tag(tag_t tag_in) { m_tag = tag_in; return std::move(*this); }
  inline post_am_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline post_am_x&& allow_done(bool allow_done_in) { m_allow_done = allow_done_in; return std::move(*this); }
  inline post_am_x&& allow_posted(bool allow_posted_in) { m_allow_posted = allow_posted_in; return std::move(*this); }
  inline post_am_x&& allow_retry(bool allow_retry_in) { m_allow_retry = allow_retry_in; return std::move(*this); }
 
  status_t call_impl(int rank, void* local_buffer, size_t size, comp_t local_comp, rcomp_t remote_comp, runtime_t runtime, device_t device, endpoint_t endpoint, packet_pool_t packet_pool, comp_semantic_t comp_semantic, mr_t mr, tag_t tag, void* user_context, bool allow_done, bool allow_posted, bool allow_retry) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t post_am(int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in, rcomp_t remote_comp_in) {
  return post_am_x(rank_in, local_buffer_in, size_in, local_comp_in, remote_comp_in).call();
}
 

 
class post_send_x {
 public:
  // args declaration
  int m_rank;
  void* m_local_buffer;
  size_t m_size;
  tag_t m_tag;
  comp_t m_local_comp;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<packet_pool_t> m_packet_pool ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<mr_t> m_mr ;
  option_t<void*> m_user_context ;
  option_t<matching_policy_t> m_matching_policy ;
  option_t<bool> m_allow_done ;
  option_t<bool> m_allow_posted ;
  option_t<bool> m_allow_retry ;
 
  // constructor
  post_send_x(int rank_in, void* local_buffer_in, size_t size_in, tag_t tag_in, comp_t local_comp_in) : m_rank(rank_in), m_local_buffer(local_buffer_in), m_size(size_in), m_tag(tag_in), m_local_comp(local_comp_in) {}
 
  // setter
  inline post_send_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline post_send_x&& local_buffer(void* local_buffer_in) { m_local_buffer = local_buffer_in; return std::move(*this); }
  inline post_send_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline post_send_x&& tag(tag_t tag_in) { m_tag = tag_in; return std::move(*this); }
  inline post_send_x&& local_comp(comp_t local_comp_in) { m_local_comp = local_comp_in; return std::move(*this); }
  inline post_send_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline post_send_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline post_send_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline post_send_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline post_send_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline post_send_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline post_send_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline post_send_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline post_send_x&& matching_policy(matching_policy_t matching_policy_in) { m_matching_policy = matching_policy_in; return std::move(*this); }
  inline post_send_x&& allow_done(bool allow_done_in) { m_allow_done = allow_done_in; return std::move(*this); }
  inline post_send_x&& allow_posted(bool allow_posted_in) { m_allow_posted = allow_posted_in; return std::move(*this); }
  inline post_send_x&& allow_retry(bool allow_retry_in) { m_allow_retry = allow_retry_in; return std::move(*this); }
 
  status_t call_impl(int rank, void* local_buffer, size_t size, tag_t tag, comp_t local_comp, runtime_t runtime, device_t device, endpoint_t endpoint, packet_pool_t packet_pool, matching_engine_t matching_engine, comp_semantic_t comp_semantic, mr_t mr, void* user_context, matching_policy_t matching_policy, bool allow_done, bool allow_posted, bool allow_retry) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t post_send(int rank_in, void* local_buffer_in, size_t size_in, tag_t tag_in, comp_t local_comp_in) {
  return post_send_x(rank_in, local_buffer_in, size_in, tag_in, local_comp_in).call();
}
 

 
class post_recv_x {
 public:
  // args declaration
  int m_rank;
  void* m_local_buffer;
  size_t m_size;
  tag_t m_tag;
  comp_t m_local_comp;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<packet_pool_t> m_packet_pool ;
  option_t<matching_engine_t> m_matching_engine ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<mr_t> m_mr ;
  option_t<void*> m_user_context ;
  option_t<matching_policy_t> m_matching_policy ;
  option_t<bool> m_allow_done ;
  option_t<bool> m_allow_posted ;
  option_t<bool> m_allow_retry ;
 
  // constructor
  post_recv_x(int rank_in, void* local_buffer_in, size_t size_in, tag_t tag_in, comp_t local_comp_in) : m_rank(rank_in), m_local_buffer(local_buffer_in), m_size(size_in), m_tag(tag_in), m_local_comp(local_comp_in) {}
 
  // setter
  inline post_recv_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline post_recv_x&& local_buffer(void* local_buffer_in) { m_local_buffer = local_buffer_in; return std::move(*this); }
  inline post_recv_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline post_recv_x&& tag(tag_t tag_in) { m_tag = tag_in; return std::move(*this); }
  inline post_recv_x&& local_comp(comp_t local_comp_in) { m_local_comp = local_comp_in; return std::move(*this); }
  inline post_recv_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline post_recv_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline post_recv_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline post_recv_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline post_recv_x&& matching_engine(matching_engine_t matching_engine_in) { m_matching_engine = matching_engine_in; return std::move(*this); }
  inline post_recv_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline post_recv_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline post_recv_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline post_recv_x&& matching_policy(matching_policy_t matching_policy_in) { m_matching_policy = matching_policy_in; return std::move(*this); }
  inline post_recv_x&& allow_done(bool allow_done_in) { m_allow_done = allow_done_in; return std::move(*this); }
  inline post_recv_x&& allow_posted(bool allow_posted_in) { m_allow_posted = allow_posted_in; return std::move(*this); }
  inline post_recv_x&& allow_retry(bool allow_retry_in) { m_allow_retry = allow_retry_in; return std::move(*this); }
 
  status_t call_impl(int rank, void* local_buffer, size_t size, tag_t tag, comp_t local_comp, runtime_t runtime, device_t device, endpoint_t endpoint, packet_pool_t packet_pool, matching_engine_t matching_engine, comp_semantic_t comp_semantic, mr_t mr, void* user_context, matching_policy_t matching_policy, bool allow_done, bool allow_posted, bool allow_retry) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t post_recv(int rank_in, void* local_buffer_in, size_t size_in, tag_t tag_in, comp_t local_comp_in) {
  return post_recv_x(rank_in, local_buffer_in, size_in, tag_in, local_comp_in).call();
}
 

 
class post_put_x {
 public:
  // args declaration
  int m_rank;
  void* m_local_buffer;
  size_t m_size;
  comp_t m_local_comp;
  uintptr_t m_remote_disp;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<packet_pool_t> m_packet_pool ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<mr_t> m_mr ;
  option_t<tag_t> m_tag ;
  option_t<rcomp_t> m_remote_comp ;
  option_t<void*> m_user_context ;
  option_t<bool> m_allow_done ;
  option_t<bool> m_allow_posted ;
  option_t<bool> m_allow_retry ;
 
  // constructor
  post_put_x(int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in, uintptr_t remote_disp_in, rmr_t rmr_in) : m_rank(rank_in), m_local_buffer(local_buffer_in), m_size(size_in), m_local_comp(local_comp_in), m_remote_disp(remote_disp_in), m_rmr(rmr_in) {}
 
  // setter
  inline post_put_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline post_put_x&& local_buffer(void* local_buffer_in) { m_local_buffer = local_buffer_in; return std::move(*this); }
  inline post_put_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline post_put_x&& local_comp(comp_t local_comp_in) { m_local_comp = local_comp_in; return std::move(*this); }
  inline post_put_x&& remote_disp(uintptr_t remote_disp_in) { m_remote_disp = remote_disp_in; return std::move(*this); }
  inline post_put_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline post_put_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline post_put_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline post_put_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline post_put_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline post_put_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline post_put_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline post_put_x&& tag(tag_t tag_in) { m_tag = tag_in; return std::move(*this); }
  inline post_put_x&& remote_comp(rcomp_t remote_comp_in) { m_remote_comp = remote_comp_in; return std::move(*this); }
  inline post_put_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline post_put_x&& allow_done(bool allow_done_in) { m_allow_done = allow_done_in; return std::move(*this); }
  inline post_put_x&& allow_posted(bool allow_posted_in) { m_allow_posted = allow_posted_in; return std::move(*this); }
  inline post_put_x&& allow_retry(bool allow_retry_in) { m_allow_retry = allow_retry_in; return std::move(*this); }
 
  status_t call_impl(int rank, void* local_buffer, size_t size, comp_t local_comp, uintptr_t remote_disp, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, packet_pool_t packet_pool, comp_semantic_t comp_semantic, mr_t mr, tag_t tag, rcomp_t remote_comp, void* user_context, bool allow_done, bool allow_posted, bool allow_retry) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t post_put(int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in, uintptr_t remote_disp_in, rmr_t rmr_in) {
  return post_put_x(rank_in, local_buffer_in, size_in, local_comp_in, remote_disp_in, rmr_in).call();
}
 

 
class post_get_x {
 public:
  // args declaration
  int m_rank;
  void* m_local_buffer;
  size_t m_size;
  comp_t m_local_comp;
  uintptr_t m_remote_disp;
  rmr_t m_rmr;
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
  option_t<packet_pool_t> m_packet_pool ;
  option_t<comp_semantic_t> m_comp_semantic ;
  option_t<mr_t> m_mr ;
  option_t<tag_t> m_tag ;
  option_t<rcomp_t> m_remote_comp ;
  option_t<void*> m_user_context ;
  option_t<bool> m_allow_done ;
  option_t<bool> m_allow_posted ;
  option_t<bool> m_allow_retry ;
 
  // constructor
  post_get_x(int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in, uintptr_t remote_disp_in, rmr_t rmr_in) : m_rank(rank_in), m_local_buffer(local_buffer_in), m_size(size_in), m_local_comp(local_comp_in), m_remote_disp(remote_disp_in), m_rmr(rmr_in) {}
 
  // setter
  inline post_get_x&& rank(int rank_in) { m_rank = rank_in; return std::move(*this); }
  inline post_get_x&& local_buffer(void* local_buffer_in) { m_local_buffer = local_buffer_in; return std::move(*this); }
  inline post_get_x&& size(size_t size_in) { m_size = size_in; return std::move(*this); }
  inline post_get_x&& local_comp(comp_t local_comp_in) { m_local_comp = local_comp_in; return std::move(*this); }
  inline post_get_x&& remote_disp(uintptr_t remote_disp_in) { m_remote_disp = remote_disp_in; return std::move(*this); }
  inline post_get_x&& rmr(rmr_t rmr_in) { m_rmr = rmr_in; return std::move(*this); }
  inline post_get_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline post_get_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline post_get_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
  inline post_get_x&& packet_pool(packet_pool_t packet_pool_in) { m_packet_pool = packet_pool_in; return std::move(*this); }
  inline post_get_x&& comp_semantic(comp_semantic_t comp_semantic_in) { m_comp_semantic = comp_semantic_in; return std::move(*this); }
  inline post_get_x&& mr(mr_t mr_in) { m_mr = mr_in; return std::move(*this); }
  inline post_get_x&& tag(tag_t tag_in) { m_tag = tag_in; return std::move(*this); }
  inline post_get_x&& remote_comp(rcomp_t remote_comp_in) { m_remote_comp = remote_comp_in; return std::move(*this); }
  inline post_get_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline post_get_x&& allow_done(bool allow_done_in) { m_allow_done = allow_done_in; return std::move(*this); }
  inline post_get_x&& allow_posted(bool allow_posted_in) { m_allow_posted = allow_posted_in; return std::move(*this); }
  inline post_get_x&& allow_retry(bool allow_retry_in) { m_allow_retry = allow_retry_in; return std::move(*this); }
 
  status_t call_impl(int rank, void* local_buffer, size_t size, comp_t local_comp, uintptr_t remote_disp, rmr_t rmr, runtime_t runtime, device_t device, endpoint_t endpoint, packet_pool_t packet_pool, comp_semantic_t comp_semantic, mr_t mr, tag_t tag, rcomp_t remote_comp, void* user_context, bool allow_done, bool allow_posted, bool allow_retry) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t post_get(int rank_in, void* local_buffer_in, size_t size_in, comp_t local_comp_in, uintptr_t remote_disp_in, rmr_t rmr_in) {
  return post_get_x(rank_in, local_buffer_in, size_in, local_comp_in, remote_disp_in, rmr_in).call();
}
 

 
class progress_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
  option_t<endpoint_t> m_endpoint ;
 
  // constructor
  progress_x() {}
 
  // setter
  inline progress_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline progress_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
  inline progress_x&& endpoint(endpoint_t endpoint_in) { m_endpoint = endpoint_in; return std::move(*this); }
 
  error_t call_impl(runtime_t runtime, device_t device, endpoint_t endpoint) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t progress() {
  return progress_x().call();
}
 

 
class test_drained_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
 
  // constructor
  test_drained_x() {}
 
  // setter
  inline test_drained_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline test_drained_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  error_t call_impl(runtime_t runtime, device_t device) const;
  error_t call() const;
  inline error_t operator()() const { return call(); }
};
 
inline error_t test_drained() {
  return test_drained_x().call();
}
 

 
class wait_drained_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<device_t> m_device ;
 
  // constructor
  wait_drained_x() {}
 
  // setter
  inline wait_drained_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline wait_drained_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  void call_impl(runtime_t runtime, device_t device) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void wait_drained() {
  return wait_drained_x().call();
}
 

 
class free_comp_x {
 public:
  // args declaration
  comp_t* m_comp;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  free_comp_x(comp_t* comp_in) : m_comp(comp_in) {}
 
  // setter
  inline free_comp_x&& comp(comp_t* comp_in) { m_comp = comp_in; return std::move(*this); }
  inline free_comp_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(comp_t* comp, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void free_comp(comp_t* comp_in) {
  return free_comp_x(comp_in).call();
}
 

 
class comp_signal_x {
 public:
  // args declaration
  comp_t m_comp;
  status_t m_status;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  comp_signal_x(comp_t comp_in, status_t status_in) : m_comp(comp_in), m_status(status_in) {}
 
  // setter
  inline comp_signal_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline comp_signal_x&& status(status_t status_in) { m_status = status_in; return std::move(*this); }
  inline comp_signal_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(comp_t comp, status_t status, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void comp_signal(comp_t comp_in, status_t status_in) {
  return comp_signal_x(comp_in, status_in).call();
}
 

 
class reserve_rcomps_x {
 public:
  // args declaration
  rcomp_t m_n;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  reserve_rcomps_x(rcomp_t n_in) : m_n(n_in) {}
 
  // setter
  inline reserve_rcomps_x&& n(rcomp_t n_in) { m_n = n_in; return std::move(*this); }
  inline reserve_rcomps_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  rcomp_t call_impl(rcomp_t n, runtime_t runtime) const;
  rcomp_t call() const;
  inline rcomp_t operator()() const { return call(); }
};
 
inline rcomp_t reserve_rcomps(rcomp_t n_in) {
  return reserve_rcomps_x(n_in).call();
}
 

 
class register_rcomp_x {
 public:
  // args declaration
  comp_t m_comp;
  option_t<runtime_t> m_runtime ;
  option_t<rcomp_t> m_rcomp ;
 
  // constructor
  register_rcomp_x(comp_t comp_in) : m_comp(comp_in) {}
 
  // setter
  inline register_rcomp_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline register_rcomp_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline register_rcomp_x&& rcomp(rcomp_t rcomp_in) { m_rcomp = rcomp_in; return std::move(*this); }
 
  rcomp_t call_impl(comp_t comp, runtime_t runtime, rcomp_t rcomp) const;
  rcomp_t call() const;
  inline rcomp_t operator()() const { return call(); }
};
 
inline rcomp_t register_rcomp(comp_t comp_in) {
  return register_rcomp_x(comp_in).call();
}
 

 
class deregister_rcomp_x {
 public:
  // args declaration
  rcomp_t m_rcomp;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  deregister_rcomp_x(rcomp_t rcomp_in) : m_rcomp(rcomp_in) {}
 
  // setter
  inline deregister_rcomp_x&& rcomp(rcomp_t rcomp_in) { m_rcomp = rcomp_in; return std::move(*this); }
  inline deregister_rcomp_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(rcomp_t rcomp, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void deregister_rcomp(rcomp_t rcomp_in) {
  return deregister_rcomp_x(rcomp_in).call();
}
 

 
class alloc_sync_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<int> m_threshold ;
  option_t<bool> m_zero_copy_am ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
 
  // constructor
  alloc_sync_x() {}
 
  // setter
  inline alloc_sync_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alloc_sync_x&& threshold(int threshold_in) { m_threshold = threshold_in; return std::move(*this); }
  inline alloc_sync_x&& zero_copy_am(bool zero_copy_am_in) { m_zero_copy_am = zero_copy_am_in; return std::move(*this); }
  inline alloc_sync_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_sync_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  comp_t call_impl(runtime_t runtime, int threshold, bool zero_copy_am, const char* name, void* user_context) const;
  comp_t call() const;
  inline comp_t operator()() const { return call(); }
};
 
inline comp_t alloc_sync() {
  return alloc_sync_x().call();
}
 

 
class sync_test_x {
 public:
  // args declaration
  comp_t m_comp;
  status_t* m_p_out;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  sync_test_x(comp_t comp_in, status_t* p_out_in) : m_comp(comp_in), m_p_out(p_out_in) {}
 
  // setter
  inline sync_test_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline sync_test_x&& p_out(status_t* p_out_in) { m_p_out = p_out_in; return std::move(*this); }
  inline sync_test_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  bool call_impl(comp_t comp, status_t* p_out, runtime_t runtime) const;
  bool call() const;
  inline bool operator()() const { return call(); }
};
 
inline bool sync_test(comp_t comp_in, status_t* p_out_in) {
  return sync_test_x(comp_in, p_out_in).call();
}
 

 
class sync_wait_x {
 public:
  // args declaration
  comp_t m_comp;
  status_t* m_p_out;
  option_t<runtime_t> m_runtime ;
  option_t<bool> m_do_progress ;
  option_t<device_t> m_device ;
 
  // constructor
  sync_wait_x(comp_t comp_in, status_t* p_out_in) : m_comp(comp_in), m_p_out(p_out_in) {}
 
  // setter
  inline sync_wait_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline sync_wait_x&& p_out(status_t* p_out_in) { m_p_out = p_out_in; return std::move(*this); }
  inline sync_wait_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline sync_wait_x&& do_progress(bool do_progress_in) { m_do_progress = do_progress_in; return std::move(*this); }
  inline sync_wait_x&& device(device_t device_in) { m_device = device_in; return std::move(*this); }
 
  void call_impl(comp_t comp, status_t* p_out, runtime_t runtime, bool do_progress, device_t device) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void sync_wait(comp_t comp_in, status_t* p_out_in) {
  return sync_wait_x(comp_in, p_out_in).call();
}
 

 
class alloc_counter_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
 
  // constructor
  alloc_counter_x() {}
 
  // setter
  inline alloc_counter_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alloc_counter_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_counter_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  comp_t call_impl(runtime_t runtime, const char* name, void* user_context) const;
  comp_t call() const;
  inline comp_t operator()() const { return call(); }
};
 
inline comp_t alloc_counter() {
  return alloc_counter_x().call();
}
 

 
class counter_get_x {
 public:
  // args declaration
  comp_t m_comp;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  counter_get_x(comp_t comp_in) : m_comp(comp_in) {}
 
  // setter
  inline counter_get_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline counter_get_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  int64_t call_impl(comp_t comp, runtime_t runtime) const;
  int64_t call() const;
  inline int64_t operator()() const { return call(); }
};
 
inline int64_t counter_get(comp_t comp_in) {
  return counter_get_x(comp_in).call();
}
 

 
class counter_set_x {
 public:
  // args declaration
  comp_t m_comp;
  int64_t m_value;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  counter_set_x(comp_t comp_in, int64_t value_in) : m_comp(comp_in), m_value(value_in) {}
 
  // setter
  inline counter_set_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline counter_set_x&& value(int64_t value_in) { m_value = value_in; return std::move(*this); }
  inline counter_set_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(comp_t comp, int64_t value, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void counter_set(comp_t comp_in, int64_t value_in) {
  return counter_set_x(comp_in, value_in).call();
}
 

 
class alloc_cq_x {
 public:
  // args declaration
  option_t<runtime_t> m_runtime ;
  option_t<int> m_default_length ;
  option_t<bool> m_zero_copy_am ;
  option_t<attr_cq_type_t> m_cq_type ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
 
  // constructor
  alloc_cq_x() {}
 
  // setter
  inline alloc_cq_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alloc_cq_x&& default_length(int default_length_in) { m_default_length = default_length_in; return std::move(*this); }
  inline alloc_cq_x&& zero_copy_am(bool zero_copy_am_in) { m_zero_copy_am = zero_copy_am_in; return std::move(*this); }
  inline alloc_cq_x&& cq_type(attr_cq_type_t cq_type_in) { m_cq_type = cq_type_in; return std::move(*this); }
  inline alloc_cq_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_cq_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  comp_t call_impl(runtime_t runtime, int default_length, bool zero_copy_am, attr_cq_type_t cq_type, const char* name, void* user_context) const;
  comp_t call() const;
  inline comp_t operator()() const { return call(); }
};
 
inline comp_t alloc_cq() {
  return alloc_cq_x().call();
}
 

 
class cq_pop_x {
 public:
  // args declaration
  comp_t m_comp;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  cq_pop_x(comp_t comp_in) : m_comp(comp_in) {}
 
  // setter
  inline cq_pop_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline cq_pop_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  status_t call_impl(comp_t comp, runtime_t runtime) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t cq_pop(comp_t comp_in) {
  return cq_pop_x(comp_in).call();
}
 

 
class alloc_handler_x {
 public:
  // args declaration
  comp_handler_t m_handler;
  option_t<runtime_t> m_runtime ;
  option_t<bool> m_zero_copy_am ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
 
  // constructor
  alloc_handler_x(comp_handler_t handler_in) : m_handler(handler_in) {}
 
  // setter
  inline alloc_handler_x&& handler(comp_handler_t handler_in) { m_handler = handler_in; return std::move(*this); }
  inline alloc_handler_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
  inline alloc_handler_x&& zero_copy_am(bool zero_copy_am_in) { m_zero_copy_am = zero_copy_am_in; return std::move(*this); }
  inline alloc_handler_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_handler_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
 
  comp_t call_impl(comp_handler_t handler, runtime_t runtime, bool zero_copy_am, const char* name, void* user_context) const;
  comp_t call() const;
  inline comp_t operator()() const { return call(); }
};
 
inline comp_t alloc_handler(comp_handler_t handler_in) {
  return alloc_handler_x(handler_in).call();
}
 

 
class alloc_graph_x {
 public:
  // args declaration
  option_t<comp_t> m_comp ;
  option_t<const char*> m_name ;
  option_t<void*> m_user_context ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  alloc_graph_x() {}
 
  // setter
  inline alloc_graph_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline alloc_graph_x&& name(const char* name_in) { m_name = name_in; return std::move(*this); }
  inline alloc_graph_x&& user_context(void* user_context_in) { m_user_context = user_context_in; return std::move(*this); }
  inline alloc_graph_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  comp_t call_impl(comp_t comp, const char* name, void* user_context, runtime_t runtime) const;
  comp_t call() const;
  inline comp_t operator()() const { return call(); }
};
 
inline comp_t alloc_graph() {
  return alloc_graph_x().call();
}
 

 
class graph_add_node_x {
 public:
  // args declaration
  comp_t m_comp;
  graph_node_run_cb_t m_fn;
  option_t<void*> m_value ;
  option_t<graph_node_free_cb_t> m_free_cb ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  graph_add_node_x(comp_t comp_in, graph_node_run_cb_t fn_in) : m_comp(comp_in), m_fn(fn_in) {}
 
  // setter
  inline graph_add_node_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline graph_add_node_x&& fn(graph_node_run_cb_t fn_in) { m_fn = fn_in; return std::move(*this); }
  inline graph_add_node_x&& value(void* value_in) { m_value = value_in; return std::move(*this); }
  inline graph_add_node_x&& free_cb(graph_node_free_cb_t free_cb_in) { m_free_cb = free_cb_in; return std::move(*this); }
  inline graph_add_node_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  graph_node_t call_impl(comp_t comp, graph_node_run_cb_t fn, void* value, graph_node_free_cb_t free_cb, runtime_t runtime) const;
  graph_node_t call() const;
  inline graph_node_t operator()() const { return call(); }
};
 
inline graph_node_t graph_add_node(comp_t comp_in, graph_node_run_cb_t fn_in) {
  return graph_add_node_x(comp_in, fn_in).call();
}
 

 
class graph_add_edge_x {
 public:
  // args declaration
  comp_t m_comp;
  graph_node_t m_src;
  graph_node_t m_dst;
  option_t<graph_edge_run_cb_t> m_fn ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  graph_add_edge_x(comp_t comp_in, graph_node_t src_in, graph_node_t dst_in) : m_comp(comp_in), m_src(src_in), m_dst(dst_in) {}
 
  // setter
  inline graph_add_edge_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline graph_add_edge_x&& src(graph_node_t src_in) { m_src = src_in; return std::move(*this); }
  inline graph_add_edge_x&& dst(graph_node_t dst_in) { m_dst = dst_in; return std::move(*this); }
  inline graph_add_edge_x&& fn(graph_edge_run_cb_t fn_in) { m_fn = fn_in; return std::move(*this); }
  inline graph_add_edge_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(comp_t comp, graph_node_t src, graph_node_t dst, graph_edge_run_cb_t fn, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void graph_add_edge(comp_t comp_in, graph_node_t src_in, graph_node_t dst_in) {
  return graph_add_edge_x(comp_in, src_in, dst_in).call();
}
 

 
class graph_node_mark_complete_x {
 public:
  // args declaration
  graph_node_t m_node;
  option_t<status_t> m_status ;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  graph_node_mark_complete_x(graph_node_t node_in) : m_node(node_in) {}
 
  // setter
  inline graph_node_mark_complete_x&& node(graph_node_t node_in) { m_node = node_in; return std::move(*this); }
  inline graph_node_mark_complete_x&& status(status_t status_in) { m_status = status_in; return std::move(*this); }
  inline graph_node_mark_complete_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(graph_node_t node, status_t status, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void graph_node_mark_complete(graph_node_t node_in) {
  return graph_node_mark_complete_x(node_in).call();
}
 

 
class graph_start_x {
 public:
  // args declaration
  comp_t m_comp;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  graph_start_x(comp_t comp_in) : m_comp(comp_in) {}
 
  // setter
  inline graph_start_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline graph_start_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  void call_impl(comp_t comp, runtime_t runtime) const;
  void call() const;
  inline void operator()() const { return call(); }
};
 
inline void graph_start(comp_t comp_in) {
  return graph_start_x(comp_in).call();
}
 

 
class graph_test_x {
 public:
  // args declaration
  comp_t m_comp;
  option_t<runtime_t> m_runtime ;
 
  // constructor
  graph_test_x(comp_t comp_in) : m_comp(comp_in) {}
 
  // setter
  inline graph_test_x&& comp(comp_t comp_in) { m_comp = comp_in; return std::move(*this); }
  inline graph_test_x&& runtime(runtime_t runtime_in) { m_runtime = runtime_in; return std::move(*this); }
 
  status_t call_impl(comp_t comp, runtime_t runtime) const;
  status_t call() const;
  inline status_t operator()() const { return call(); }
};
 
inline status_t graph_test(comp_t comp_in) {
  return graph_test_x(comp_in).call();
}
 
 
} // namespace lci
 
#endif // LCI_BINDING_POST_HPP_