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