Io

CMakeLists.txt

@@ -29,7 +29,6 @@ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/doc/index.html
 
 add_custom_target(boost_async_doc DEPENDS  ${CMAKE_CURRENT_BINARY_DIR}/doc/index.html)
 
-
 if(BOOST_ASYNC_IS_ROOT)
     #include(CTest)
 endif()
@@ -79,18 +78,56 @@ if (NOT MSVC)
 endif()
 
 add_library(boost_async
-            src/detail/exception.cpp
-            src/detail/util.cpp
-            src/error.cpp
-            src/channel.cpp
-            src/main.cpp
-            src/this_thread.cpp
-            src/thread.cpp)
+        src/detail/exception.cpp
+        src/detail/util.cpp
+        src/error.cpp
+        src/channel.cpp
+        src/main.cpp
+        src/this_thread.cpp
+        src/thread.cpp
+        src/io/buffers/circular_buffer.cpp
+        src/io/buffers/const_buffer_pair.cpp
+        src/io/buffers/const_buffer_subspan.cpp
+        src/io/buffers/mutable_buffer_pair.cpp
+        src/io/buffers/mutable_buffer_subspan.cpp
+        src/io/detail/duplicate.cpp
+        src/io/detail/stream.cpp
+        src/io/acceptor.cpp
+        src/io/datagram_socket.cpp
+        src/io/endpoint.cpp
+        src/io/pipe.cpp
+        src/io/resolver.cpp
+        src/io/serial_port.cpp
+        src/io/signal_set.cpp
+        src/io/seq_packet_socket.cpp
+        src/io/socket.cpp
+        src/io/ssl.cpp
+        src/io/steady_timer.cpp
+        src/io/stream_socket.cpp
+        src/io/system_timer.cpp
+        src/io/stream_file.cpp
+        src/io/random_access_file.cpp
+        src/io/file.cpp
+        src/io/read.cpp
+        src/io/read_all.cpp
+        src/io/read_at.cpp
+        src/io/read_until.cpp
+        src/io/popen.cpp
+        src/io/process.cpp
+        src/io/buffers/register.cpp
+        src/io/write.cpp
+        src/io/write_at.cpp
+        src/io/detail/random_access_device.cpp
+        src/io/copy.cpp
+        src/io/copy_n.cpp
+        src/io/sleep.cpp)
+
 target_include_directories(boost_async PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
 target_link_libraries(boost_async PUBLIC
         Boost::system
         Threads::Threads)
 target_compile_definitions(boost_async PRIVATE BOOST_ASYNC_SOURCE=1 )
+target_compile_definitions(boost_async PUBLIC BOOST_PROCESS_USE_STD_FS=1)
 
 if (BOOST_ASYNC_USE_BOOST_CONTAINER)
     target_link_libraries(boost_async PUBLIC Boost::container)

doc/reference/io.adoc

@@ -0,0 +1,6 @@
+[#io]
+== async/io.hpp
+
+include::io/timer.adoc[]
+include::io/endpoint.adoc[]
+include::io/resolver.adoc[]

doc/reference/io/buffers/overview.adoc

@@ -0,0 +1,29 @@
+////
+Copyright (c) 2023 Vinnie Falco ([email protected])
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    Official repository: https://github.com/CPPAlliance/buffers
+////
+
+==  Overview
+
+Boost.Buffers is a portable, low-level C++ library which provides
+containers and algorithms for describing contiguous buffers of
+arbitrary bytes.
+
+Boost.Buffers offers these features:
+
+* Require only C++11
+* Works without exceptions
+* Fast compilation, few templates
+* Does not require Asio
+
+=== Requirements
+
+* Requires Boost and a compiler supporting at least C++20
+* Aliases for standard types use their Boost equivalents
+* Link to a built static or dynamic Boost library, or use header-only (see below)
+* Supports `-fno-exceptions`, detected automatically
+

doc/reference/io/endpoint.adoc

@@ -0,0 +1,132 @@
+[#io::endpoint]
+=== async/io/endpoint.hpp
+
+The endpoint header provides a simple wrapper around endpoints.
+
+The usage is simple:
+
+[source,cpp]
+----
+async::io::endpoint domain_socket{async::io::local_stream, "/var/sys/socket"};
+async::io::local_endpoint le = get<async::io::local_endpoint>(domain_socket);
+
+
+async::io::endpoint ip_socket{async::io::tcp, "192.168.0.1", 8080};
+async::io::local_endpoint le = get<async::io::ip_socket>(domain_socket);
+----
+
+NOTE: `AF_UNSPEC` is treated as an IP that's either ipv6 or ip_v4.
+
+==== Reference
+
+
+[source,cpp]
+----
+// a simple type holding the triplet to describe any endpoint
+struct protocol_type
+{
+  using family_t   = *implementation-defined*;
+  using type_t     = *implementation-defined*;
+  using protocol_t = *implementation-defined*;
+
+  constexpr family_t     family() const noexcept {return family_;};
+  constexpr type_t         type() const noexcept {return type_;};
+  constexpr protocol_t protocol() const noexcept {return protocol_;};
+
+  constexpr explicit
+  protocol_type(family_t family     = static_cast<family_t>(0),
+                type_t type         = static_cast<type_t>(0),
+                protocol_t protocol = static_cast<protocol_t>(0)) noexcept
+
+  constexpr protocol_type(const OtherProtocol & op) noexcept;
+  {}
+  // asio compatibility
+  using endpoint = endpoint;
+};
+
+// the class holding the endpiont
+struct endpoint
+{
+  using storage_type = boost::asio::detail::sockaddr_storage_type;
+  using addr_type = boost::asio::detail::socket_addr_type;
+  void resize(std::size_t size);
+
+        void * data();
+  const void * data() const;
+  std::size_t size();
+
+  protocol_type protocol() const;
+
+  endpoint() = default;
+  endpoint(const endpoint & ep);
+
+  template<protocol_type::family_t   Family,
+           protocol_type::type_t     Type,
+           protocol_type::protocol_t Protocol,
+           typename ... Args>
+  endpoint(static_protocol<Family, Type, Protocol> proto, Args && ... args);
+
+};
+
+// get the type of the endpoint family, see below.
+cosnt auto * get_if(const endpoint * ep);
+// get the type of the endpoint family, see below. throws `bad_endpoint_access` if a mismatched.
+const auto & get(const endpoint & ep);
+----
+
+To make it type-safe, the library provides a `static_protocol` template:
+
+[source,cpp]
+----
+template<protocol_type::family_t   Family   = static_cast<protocol_type::family_t>(0),
+         protocol_type::type_t     Type     = static_cast<protocol_type::type_t>(0),
+         protocol_type::protocol_t Protocol = static_cast<protocol_type::protocol_t>(0)>
+struct static_protocol
+{
+  using family_t   = protocol_type::family_t  ;
+  using type_t     = protocol_type::type_t    ;
+  using protocol_t = protocol_type::protocol_t;
+
+  constexpr family_t   family()   const noexcept {return Family;};
+  constexpr type_t     type()     const noexcept {return Type;};
+  constexpr protocol_t protocol() const noexcept {return Protocol;};
+
+  using endpoint = endpoint;
+};
+----
+
+These can be used to define a constexpr constant for an endpoint type. The following are provided:
+
+[source,cpp]
+----
+constexpr static_protocol<AF_UNSPEC, SOCK_STREAM, IPPROTO_IP>   ip    {};
+constexpr static_protocol<AF_INET,   SOCK_STREAM, IPPROTO_IP>   ip_v4 {};
+constexpr static_protocol<AF_INET6,  SOCK_STREAM, IPPROTO_IP>   ip_v6 {};
+constexpr static_protocol<AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP>  tcp   {};
+constexpr static_protocol<AF_INET,   SOCK_STREAM, IPPROTO_TCP>  tcp_v4{};
+constexpr static_protocol<AF_INET6,  SOCK_STREAM, IPPROTO_TCP>  tcp_v6{};
+constexpr static_protocol<AF_UNSPEC, SOCK_DGRAM,  IPPROTO_UDP>  udp   {};
+constexpr static_protocol<AF_INET,   SOCK_DGRAM,  IPPROTO_UDP>  udp_v4{};
+constexpr static_protocol<AF_INET6,  SOCK_DGRAM,  IPPROTO_ICMP> udp_v6{};
+constexpr static_protocol<AF_UNSPEC, SOCK_DGRAM,  IPPROTO_ICMP> icmp  {};
+constexpr static_protocol<AF_UNIX,   SOCK_STREAM>               local_stream   {};
+constexpr static_protocol<AF_UNIX,   SOCK_DGRAM>                local_datagram {};
+constexpr static_protocol<AF_UNIX,   SOCK_SEQPACKET>            local_seqpacket{};
+constexpr static_protocol<AF_UNIX>                              local_protocol {};
+----
+
+To add your own family type you need to implement those two `tag_invoke` functions:
+
+[source,cpp]
+----
+/// returns the size of the emplaced type.
+std::size_t tag_invoke(make_endpoint_tag<YOUR_FAMILY>,
+                       boost::asio::detail::socket_addr_type* base, // memory to in-place new
+                       ... /* the arguments you need */);
+
+/// get a pointer to the endpoint type.
+const your_endpoint* tag_invoke(get_endpoint_tag<YOUR_FAMILY>,
+                                protocol_type actual,
+                                const endpoint::addr_type * addr);
+----
+

doc/reference/io/resolver.adoc

@@ -0,0 +1,76 @@
+[#io::resolve]
+=== async/io/resolver.hpp
+
+[source,cpp]
+----
+// a simple type holding the triplet to describe any endpoint
+struct protocol_type
+{
+  using family_t   = *implementation-defined*;
+  using type_t     = *implementation-defined*;
+  using protocol_t = *implementation-defined*;
+
+  constexpr family_t     family() const noexcept {return family_;};
+  constexpr type_t         type() const noexcept {return type_;};
+  constexpr protocol_t protocol() const noexcept {return protocol_;};
+
+  constexpr explicit
+  protocol_type(family_t family     = static_cast<family_t>(0),
+                type_t type         = static_cast<type_t>(0),
+                protocol_t protocol = static_cast<protocol_t>(0)) noexcept
+
+  constexpr protocol_type(const OtherProtocol & op) noexcept;
+  {}
+  // asio compatibility
+  using endpoint = endpoint;
+};
+
+// the class holding the endpiont
+struct endpoint
+{
+  using storage_type = boost::asio::detail::sockaddr_storage_type;
+  using addr_type = boost::asio::detail::socket_addr_type;
+  void resize(std::size_t size);
+
+        void * data();
+  const void * data() const;
+  std::size_t size();
+
+  protocol_type protocol() const;
+
+  endpoint() = default;
+  endpoint(const endpoint & ep);
+
+  template<protocol_type::family_t   Family,
+           protocol_type::type_t     Type,
+           protocol_type::protocol_t Protocol,
+           typename ... Args>
+  endpoint(static_protocol<Family, Type, Protocol> proto, Args && ... args);
+
+};
+
+// get the type of the endpoint family, see below.
+cosnt auto * get_if(const endpoint * ep);
+// get the type of the endpoint family, see below. throws `bad_endpoint_access` if a mismatched.
+const auto & get(const endpoint & ep);
+----
+
+To make it type-safe, the library provides a `static_protocol` template:
+
+[source,cpp]
+----
+
+struct resolver
+{
+  using resolve_result = system::result<pmr::vector<endpoint>>;
+  resolver();
+  resolver(resolver && ) = delete;
+
+  void cancel();
+
+  awaitable<result_result> resolve_op_ resolve(core::string_view host, core::string_view service);
+};
+
+awaitable<typename resolver::resolve_result> lookup(core::string_view host, core::string_view service);
+----
+

doc/reference/io/timer.adoc

@@ -0,0 +1,52 @@
+[#io::timer]
+=== async/io/steady_timer.hpp, async/io/system_timer.hpp & async/io/sleep.hpp
+
+async.io provides simple timers based on a `std::chrono::steady_clock` and `std::chrono::system_clock`.
+
+The interface between `boost::async::io::steady_timer` and `boost::async::io::system_timer` are equivalent.
+
+[source,cpp]
+----
+struct steady_timer
+{
+
+  using wait_result = system::result<void>;
+
+  /// The clock type.
+  typedef std::chrono::steady_clock clock_type;
+
+  /// The duration type of the clock.
+  typedef typename clock_type::duration duration;
+
+  /// The time point type of the clock.
+  typedef typename clock_type::time_point time_point;
+
+  steady_timer();
+  steady_timer(const time_point& expiry_time);
+  steady_timer(const duration& expiry_duration);
+
+  void cancel();
+
+  time_point expiry() const;
+  void reset(const time_point& expiry_time);
+  void reset(const duration& expiry_time);
+  bool expired() const;
+
+  [[nodiscard]] awaitable<result<void>> wait() { return wait_op_{this}; }
+  // allow the timer to be directly be awaited
+  awaitable<result<void>> operator co_await () { return wait(); }
+};
+
+awaitable<result<void>> sleep(const steady_timer::time_point& expiry_time);
+awaitable<result<void>> sleep(const steady_timer::duration& expiry_duration);
+----
+
+==== Example
+
+[source,cpp]
+----
+async::promise<void> do_delay()
+{
+   co_await sleep(std::chrono::milliseconds(100));
+}
+----

include/boost/async/config.hpp

@@ -66,7 +66,17 @@ namespace pmr = boost::container::pmr;
 #if defined(BOOST_ASYNC_USE_STD_PMR)
 namespace pmr = std::pmr;
 #endif
-
 }
 
+# define BOOST_ASYNC_ERR(ev) ( \
+    ::boost::system::error_code( (ev), [] { \
+    static constexpr auto loc((BOOST_CURRENT_LOCATION)); \
+    return &loc; }()))
+# define BOOST_ASYNC_RETURN_EC(ev)                                     \
+    do {                                                               \
+      static constexpr auto loc ## __LINE__((BOOST_CURRENT_LOCATION)); \
+      return ::boost::system::error_code((ev), &loc ## __LINE__);      \
+    } while(false)
+
+
 #endif //BOOST_ASYNC_CONFIG_HPP