endpoint.h

#pragma once
 
#include <coroutine>
#include <cstdint>
#include <memory>
#include <ucs/type/status.h>
#include <vector>
 
#include <ucp/api/ucp.h>
 
#include "ucxpp/address.h"
#include "ucxpp/awaitable.h"
#include "ucxpp/error.h"
#include "ucxpp/memory.h"
#include "ucxpp/task.h"
#include "ucxpp/worker.h"
 
#include "ucxpp/detail/noncopyable.h"
 
namespace ucxpp {
 
class endpoint : public noncopyable,
                 public std::enable_shared_from_this<endpoint> {
  friend class worker;
  friend class local_memory_handle;
  friend class remote_memory_handle;
  friend class ep_close_awaitable;
  std::shared_ptr<worker> worker_;
  ucp_ep_h ep_;
  void *close_request_;
  remote_address peer_;
 
public:
  endpoint(std::shared_ptr<worker> worker, remote_address const &peer);
 
  static void error_cb(void *ep, ucp_ep_h ep_h, ucs_status_t status);
 
  std::shared_ptr<worker> worker_ptr() const;
 
  void print() const;
 
  ucp_ep_h handle() const;
 
  const remote_address &get_address() const;
 
  stream_send_awaitable stream_send(void const *buffer, size_t length) const;
 
  stream_recv_awaitable stream_recv(void *buffer, size_t length) const;
 
  tag_send_awaitable tag_send(void const *buffer, size_t length,
                              ucp_tag_t tag) const;
 
  ep_flush_awaitable flush() const;
 
  task<void> close();
 
  static void close_cb(void *request, ucs_status_t status, void *user_data);
 
  ~endpoint();
};
 
} // namespace ucxpp