Tmp Update: Code refactoring 1

8sileus · Mar 15, 2024 · 355fbee · 355fbee
1 parent 4e53f20
commit 355fbee
Show file tree

Hide file tree

Showing 21 changed files with 667 additions and 459 deletions.
diff --git a/tests/io_buf.cpp b/tests/io_buf.cpp
@@ -1,7 +1,8 @@
 #include "zedio/core.hpp"
 #include "zedio/fs/file.hpp"
-#include "zedio/io/buf_reader.hpp"
-#include "zedio/io/buf_writer.hpp"
+#include "zedio/io/buf/reader.hpp"
+#include "zedio/io/buf/stream.hpp"
+#include "zedio/io/buf/writer.hpp"
 #include "zedio/log.hpp"
 
 using namespace zedio::async;
@@ -19,9 +20,10 @@ auto create_file() -> Task<void> {
                    .open("read_line_test.txt");
     std::string n1 = "\n";
     std::string n2 = "\r\n";
-    auto        writer_test_move = io::BufWriter(std::move(ret.value()));
-    LOG_DEBUG("{}", writer_test_move.capacity());
-    auto writer = std::move(writer_test_move);
+    // auto        writer_test_move = io::BufWriter(std::move(ret.value()));
+    // LOG_DEBUG("{}", writer_test_move.capacity());
+    // auto writer = std::move(writer_test_move);
+    auto writer = io::BufStream(std::move(ret.value()));
     for (int i = 0; i <= 10000; i += 1) {
         if (i & 1) {
             co_await writer.write_all(std::to_string(i) + n1);
@@ -52,7 +54,7 @@ auto read_line() -> Task<void> {
     } else {
         LOG_ERROR("{} {}", meta.error().value(), meta.error().message());
     }
-    auto        reader = io::BufReader(std::move(ret.value()));
+    auto              reader = io::BufReader(std::move(ret.value()));
     std::vector<char> line;
     while (true) {
         if (auto ret = co_await reader.read_line(line); !ret || ret.value() == 0) {

diff --git a/zedio/common/concepts.hpp b/zedio/common/concepts.hpp
@@ -3,7 +3,6 @@
 // C++
 #include <concepts>
 #include <coroutine>
-#include <ranges>
 #include <span>
 // Linux
 #include <sys/socket.h>
@@ -24,6 +23,6 @@ concept is_awaiter = requires(IOAwaiter awaiter) {
 };
 
 template <typename C>
-concept constructible_to_char_splice = requires(C c) { std::span<char>{c}; };
+concept constructible_to_char_splice = requires(C c) { std::span<const char>{c}; };
 
 } // namespace zedio
diff --git a/zedio/fs/file.hpp b/zedio/fs/file.hpp
@@ -28,8 +28,8 @@ class File {
 
     template <typename... Ts>
     [[REMEMBER_CO_AWAIT]]
-    auto write_vectored(Ts &...bufs) noexcept {
-        return io_.write_vectored(bufs...);
+    auto write_vectored(Ts &&...bufs) noexcept {
+        return io_.write_vectored(std::forward<Ts>(bufs)...);
     }
 
     [[REMEMBER_CO_AWAIT]]

diff --git a/zedio/io/awaiter/readv.hpp b/zedio/io/awaiter/readv.hpp
@@ -23,35 +23,6 @@ namespace detail {
         }
     };
 
-    template <typename... Ts>
-        requires(constructible_to_char_splice<Ts> && ...)
-    class ReadVectored : public IORegistrator<ReadVectored<Ts...>> {
-    private:
-        using Super = IORegistrator<ReadVectored<Ts...>>;
-        constexpr static auto N = sizeof...(Ts);
-
-    public:
-        ReadVectored(int fd,Ts&...bufs)
-                : Super{io_uring_prep_readv,fd, nullptr,N,static_cast<std::size_t>(-1)}
-                , iovecs_{ iovec{
-                  .iov_base = std::span<char>(bufs).data(),
-                  .iov_len = std::span<char>(bufs).size_bytes(),
-                }...} {
-            this->sqe_->addr = reinterpret_cast<unsigned long long>(iovecs_.data());
-        }
-
-        auto await_resume() const noexcept -> Result<std::size_t> {
-            if (this->cb_.result_ >= 0) [[likely]] {
-                return static_cast<std::size_t>(this->cb_.result_);
-            } else {
-                return ::std::unexpected{make_sys_error(-this->cb_.result_)};
-            }
-        }
-
-    private:
-        std::array<struct iovec, N> iovecs_;
-    };
-
 } // namespace detail
 
 [[REMEMBER_CO_AWAIT]]

diff --git a/zedio/io/awaiter/recvfrom.hpp b/zedio/io/awaiter/recvfrom.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "zedio/io/base/registrator.hpp"
+
+namespace zedio::io {
+
+// TODOOODOOOOO wait io_uring_prep_recvfrom
+
+namespace detail {
+
+    class RecvFrom : public IORegistrator<RecvFrom> {
+    private:
+        using Super = IORegistrator<RecvFrom>;
+
+    public:
+        RecvFrom(int              sockfd,
+                 void            *buf,
+                 size_t           len,
+                 int              flags,
+                 struct sockaddr *addr,
+                 socklen_t       *addrlen)
+            : Super{io_uring_prep_recvmsg, sockfd, &msg_, flags}
+            , iovec_{.iov_base = buf, .iov_len = len}
+            , msg_{.msg_name = addr,
+                   .msg_namelen = addrlen != nullptr ? *addrlen : 0,
+                   .msg_iov = &iovec_,
+                   .msg_iovlen = len,
+                   .msg_control = nullptr,
+                   .msg_controllen = 0,
+                   .msg_flags = flags}
+            , addrlen_{addrlen} {}
+
+        auto await_resume() const noexcept -> Result<std::size_t> {
+            if (addrlen_) {
+                *addrlen_ = msg_.msg_namelen;
+            }
+            if (this->cb_.result_ >= 0) [[likely]] {
+                return static_cast<std::size_t>(this->cb_.result_);
+            } else {
+                return ::std::unexpected{make_sys_error(-this->cb_.result_)};
+            }
+        }
+
+    private:
+        struct iovec  iovec_;
+        struct msghdr msg_ ;
+        socklen_t    *addrlen_;
+    };
+
+} // namespace detail
+
+[[REMEMBER_CO_AWAIT]]
+static inline auto
+recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *addrlen) {
+    return detail::RecvFrom{sockfd, buf, len, flags, addr, addrlen};
+}
+
+} // namespace zedio::io
diff --git a/zedio/io/awaiter/send.hpp b/zedio/io/awaiter/send.hpp
@@ -23,11 +23,33 @@ namespace detail {
         }
     };
 
+    class SendZC : public IORegistrator<SendZC> {
+    private:
+        using Super = IORegistrator<SendZC>;
+
+    public:
+        SendZC(int sockfd, const void *buf, size_t len, int flags, unsigned zc_flags)
+            : Super{io_uring_prep_send_zc, sockfd, buf, len, flags, zc_flags} {}
+
+        auto await_resume() const noexcept -> Result<std::size_t> {
+            if (this->cb_.result_ >= 0) [[likely]] {
+                return static_cast<std::size_t>(this->cb_.result_);
+            } else {
+                return ::std::unexpected{make_sys_error(-this->cb_.result_)};
+            }
+        }
+    };
+
 } // namespace detail
 
 [[REMEMBER_CO_AWAIT]]
 static inline auto send(int sockfd, const void *buf, size_t len, int flags) {
     return detail::Send{sockfd, buf, len, flags};
 }
 
+[[REMEMBER_CO_AWAIT]]
+static inline auto send_zc(int sockfd, const void *buf, size_t len, int flags, unsigned zc_flags) {
+    return detail::SendZC{sockfd, buf, len, flags, zc_flags};
+}
+
 } // namespace zedio::io
diff --git a/zedio/io/awaiter/sendmsg.hpp b/zedio/io/awaiter/sendmsg.hpp
@@ -23,11 +23,33 @@ namespace detail {
         }
     };
 
+    class SendMsgZC : public IORegistrator<SendMsgZC> {
+    private:
+        using Super = IORegistrator<SendMsgZC>;
+
+    public:
+        SendMsgZC(int fd, const struct msghdr *msg, unsigned flags)
+            : Super{io_uring_prep_sendmsg_zc, fd, msg, flags} {}
+
+        auto await_resume() const noexcept -> Result<std::size_t> {
+            if (this->cb_.result_ >= 0) [[likely]] {
+                return static_cast<std::size_t>(this->cb_.result_);
+            } else {
+                return ::std::unexpected{make_sys_error(-this->cb_.result_)};
+            }
+        }
+    };
+
 } // namespace detail
 
 [[REMEMBER_CO_AWAIT]]
 static inline auto sendmsg(int fd, const struct msghdr *msg, unsigned flags) {
     return detail::SendMsg{fd, msg, flags};
 }
 
+[[REMEMBER_CO_AWAIT]]
+static inline auto sendmsg_zc(int fd, const struct msghdr *msg, unsigned flags) {
+    return detail::SendMsgZC{fd, msg, flags};
+}
+
 } // namespace zedio::io
diff --git a/zedio/io/awaiter/writev.hpp b/zedio/io/awaiter/writev.hpp
@@ -23,35 +23,6 @@ namespace detail {
         }
     };
 
-    template <typename... Ts>
-        requires(constructible_to_char_splice<Ts> && ...)
-    class WriteVectored : public IORegistrator<WriteVectored<Ts...>> {
-    private:
-        using Super = IORegistrator<WriteVectored<Ts...>>;
-        constexpr static auto N = sizeof...(Ts);
-
-    public:
-        WriteVectored(int fd,Ts&&...bufs)
-                : Super{io_uring_prep_writev,fd, nullptr, N, static_cast<std::size_t>(-1)}
-                , iovecs_{ iovec{
-                  .iov_base = const_cast<char*>(std::span<const char>(bufs).data()),
-                  .iov_len = std::span<const char>(bufs).size_bytes(),
-                }...} {
-            this->sqe_->addr = reinterpret_cast<unsigned long long>(iovecs_.data());
-        }
-
-        auto await_resume() const noexcept -> Result<std::size_t> {
-            if (this->cb_.result_ >= 0) [[likely]] {
-                return static_cast<std::size_t>(this->cb_.result_);
-            } else {
-                return ::std::unexpected{make_sys_error(-this->cb_.result_)};
-            }
-        }
-
-    private:
-        std::array<struct iovec, N> iovecs_;
-    };
-
 } // namespace detail
 
 [[REMEMBER_CO_AWAIT]]