internal_utils.h

Go to the documentation of this file.

// uvco (c) 2023 Lewin Bormann. See LICENSE for specific terms.
 
#pragma once
 
#include <boost/assert.hpp>
#include <fmt/core.h>
#include <string_view>
#include <uv.h>
#include <uv/unix.h>
 
#include <concepts>
#include <cstddef>
#include <string>
#include <utility>
 
namespace uvco {


using uv_status = int;
 
void allocator(uv_handle_t * /*unused*/, size_t sugg, uv_buf_t *buf);
 
void freeUvBuf(const uv_buf_t *buf);
 
// Checks if string_view is null-terminated. If it is, the fast path  is taken.
// Otherwise, a string is allocated which is null-terminated, and the function
// is called with it.
template <typename R, typename F>
  requires std::is_invocable_r_v<R, F, std::string_view>
R callWithNullTerminated(std::string_view view, F &&f) {
  if (view.data()[view.size()] == '\0') {
    return f(view.data());
  }
  std::string str(view);
  return f(str.c_str());
}

template <typename Into, typename Handle> Into *getData(const Handle *handle) {
  BOOST_ASSERT(handle != nullptr);
  const void *data = uv_handle_get_data((const uv_handle_t *)handle);
  BOOST_ASSERT(nullptr != data);
  return (Into *)data;
}

template <typename Into, typename Handle>
Into *getDataOrNull(const Handle *handle) {
  BOOST_ASSERT(handle != nullptr);
  const void *data = uv_handle_get_data((const uv_handle_t *)handle);
  return (Into *)data;
}

template <typename Into, typename Request>
Into *getRequestData(const Request *req) {
  BOOST_ASSERT(req != nullptr);
  const void *data = uv_req_get_data((const uv_req_t *)req);
  BOOST_ASSERT(nullptr != data);
  return (Into *)data;
}

template <typename Into, typename Request>
Into *getRequestDataOrNull(const Request *req) {
  BOOST_ASSERT(req != nullptr);
  const void *data = uv_req_get_data((const uv_req_t *)req);
  return (Into *)data;
}

template <typename Handle, typename Data>
void setData(Handle *handle, Data *data) {
  BOOST_ASSERT(handle != nullptr);
  uv_handle_set_data((uv_handle_t *)handle, (void *)data);
}

template <typename Handle> void resetData(Handle *handle) {
  BOOST_ASSERT(handle != nullptr);
  uv_handle_set_data((uv_handle_t *)handle, nullptr);
}

template <typename Request, typename Data>
void setRequestData(Request *req, Data *data) {
  BOOST_ASSERT(req != nullptr);
  uv_req_set_data((uv_req_t *)req, (void *)data);
}
 
template <typename Request> void resetRequestData(Request *req) {
  BOOST_ASSERT(req != nullptr);
  uv_req_set_data((uv_req_t *)req, (void *)nullptr);
}

template <typename Handle> bool dataIsNull(Handle *handle) {
  BOOST_ASSERT(handle != nullptr);
  return nullptr == uv_handle_get_data((const uv_handle_t *)handle);
}

template <typename Request> bool requestDataIsNull(Request *req) {
  return nullptr == uv_req_get_data((const uv_req_t *)req);
}

struct UvHandleDeleter {
  static void del(uv_handle_t *handle);
  template <typename Handle> void operator()(Handle *handle) {
    del((uv_handle_t *)handle);
  }
};
 
extern const bool TRACK_LIFETIMES;

template <typename T> class LifetimeTracker {
public:
  explicit LifetimeTracker(std::string name = "") : id_{std::move(name)} {
    if (TRACK_LIFETIMES) {
      fmt::print("ctor {}()#{}\n", typeid(T).name(), id_);
    }
  }
  LifetimeTracker(LifetimeTracker &&) noexcept {
    if (TRACK_LIFETIMES) {
      fmt::print("ctor {}()#{}\n", typeid(T).name(), id_);
    }
  }
  LifetimeTracker &operator=(LifetimeTracker && /*unused*/) noexcept {
    if (TRACK_LIFETIMES) {
      fmt::print("operator={}()#{}\n", typeid(T).name(), id_);
    }
  }
  LifetimeTracker<T> &operator=(const LifetimeTracker<T> &other) {
    if (this == &other) {
      return *this;
    }
    if (TRACK_LIFETIMES) {
      fmt::print("operator={}({})#{}\n", typeid(T).name(), other.id_, id_);
    }
    id_ = fmt::format("{}/copy", other.id_);
  }
  LifetimeTracker(const LifetimeTracker<T> &other)
      : id_{fmt::format("{}/copy", other.id_)} {
    if (TRACK_LIFETIMES) {
      fmt::print("operator={}({})#{}\n", typeid(T).name(), other.id_, id_);
    }
  }
  ~LifetimeTracker() {
    if (TRACK_LIFETIMES) {
      fmt::print("dtor ~{}()\n", typeid(T).name());
    }
  }
 
protected:
  std::string id_;
};

class FlagGuard {
public:
  FlagGuard(const FlagGuard &) = delete;
  FlagGuard(FlagGuard &&) = delete;
  FlagGuard &operator=(const FlagGuard &) = delete;
  FlagGuard &operator=(FlagGuard &&) = delete;

  explicit FlagGuard(bool &flag);
  ~FlagGuard();
 
private:
  bool &flag_;
};
 
template <typename T> class ZeroAtExit {
public:
  explicit ZeroAtExit(T **pointer) : ptr_{pointer} {}
  ZeroAtExit(const ZeroAtExit &) = delete;
  ZeroAtExit(ZeroAtExit &&) = delete;
  ZeroAtExit &operator=(const ZeroAtExit &) = delete;
  ZeroAtExit &operator=(ZeroAtExit &&) = delete;
  ~ZeroAtExit() {
    if (ptr_ != nullptr) {
      *ptr_ = nullptr;
    }
  }
 
private:
  T **ptr_ = nullptr;
};

 
} // namespace uvco