Methods to import Boost modules using C++20 Modules (problem record)

How to import Boost modules using C++20 Modules

My project case address: /yudaichen/coroutine_blog

introduction

The Modules feature introduced by C++20 has brought many benefits to C++ development, such as speeding up compilation speed and reducing duplicate inclusion of header files. Boost is a widely used collection of C++ libraries, which contains many powerful tools and libraries such as , , and . This article will explain in detail how to import these Boost modules using C++20 Modules.

Environmental preparation

Before you start, you need to make sure:

Compiler support: Use compilers that support C++20 Modules, such as GCC 10 and above, Clang 12 and above.
CMake Support: The CMake version needs to be 3.20 and above, because CMake 3.20 begins to have better support for C++20 Modules.
Boost library installation: Make sure that the Boost library is installed correctly and can be found by the compiler. You canBoost official websiteDownload the source code and compile and install it.

Project structure

First, we create a simple project structure as follows:

project/
├── 
├──

Configuration

existIn the file, we need to make some configuration to support C++20 Modules and Boost libraries. Here is an example:

cmake_minimum_required(VERSION 3.20)
project(BoostModuleExample)
# Set the C++ standard to C++20set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Find Boost Libraryfind_package(Boost REQUIRED COMPONENTS asio beast redis json)
# Add executable fileadd_executable(BoostModuleExample )
# Link Boost Librarytarget_link_libraries(BoostModuleExample PRIVATE Boost::asio Boost::beast Boost::redis Boost::json)
# Set compiler options to support Modulesif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    target_compile_options(BoostModuleExample PRIVATE -fmodules-ts)
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    target_compile_options(BoostModuleExample PRIVATE -fmodules -fcxx-modules)
endif()

Code explanation:

find_package: Used to find Boost libraries and specify required components, includingasio、beast、redisandjson。
target_link_libraries: Link the Boost library to the executable file.
target_compile_options: Set the corresponding compilation options to support C++20 Modules according to different compilers.

Importing Boost modules using C++20 Modules

accomplish

// 
module; // Global module fragment/*#include &lt;boost/&gt;*/
#include &lt;boost/asio/co_spawn.hpp&gt;
#include &lt;boost/asio/thread_pool.hpp&gt;
#include &lt;boost/asio/static_thread_pool.hpp&gt;
#include &lt;boost/asio/as_tuple.hpp&gt;
#include &lt;boost/asio/signal_set.hpp&gt;
#include &lt;boost/asio/&gt;
#include &lt;boost/asio/&gt;
#include &lt;boost/asio/io_context.hpp&gt;
#include &lt;boost/asio/ip/&gt;
#include &lt;boost/asio/ip/&gt;
#include &lt;boost/asio/&gt;
#include &lt;boost/asio/use_awaitable.hpp&gt;
//Introduce header files#include &lt;boost/beast/&gt;
#include &lt;boost/beast/&gt;
#include &lt;boost/beast/&gt;
#include &lt;boost/beast/&gt;
#include &lt;boost/beast/&gt;
//Introduce header files#include &lt;boost/&gt;
#include &lt;boost/mysql/&gt;
#include &lt;boost/mysql/handshake_params.hpp&gt;
#include &lt;boost/mysql/&gt;
//Introduce header files#include &lt;boost/&gt;
#include &lt;boost/redis/&gt;
#include &lt;boost/redis/&gt;
#include &lt;boost/redis/&gt;
//Introduce header files#include &lt;boost/json/&gt;
#include &lt;boost/json/&gt;
#include &lt;boost/json/&gt;
#include &lt;boost/json/&gt;
export module boost;
// ===================================================export namespace asio {
// --- Core component export ---using boost::asio::any_completion_executor;
using boost::asio::any_io_executor;
using boost::asio::async_connect;
using boost::asio::awaitable;
using boost::asio::bad_executor;
using boost::asio::buffer;
using boost::asio::cancellation_signal;
using boost::asio::cancellation_slot;
using boost::asio::cancellation_state;
using boost::asio::cancellation_type;
using boost::asio::co_spawn;
using boost::asio::connect;
using boost::asio::coroutine;
using boost::asio::deferred;
using boost::asio::detached;
using boost::asio::detached_t;
using boost::asio::dynamic_buffer;
using boost::asio::execution_context;
using boost::asio::executor;
using boost::asio::executor_arg_t;
using boost::asio::invalid_service_owner;
using boost::asio::io_context;
using boost::asio::multiple_exceptions;
using boost::asio::post;
using boost::asio::service_already_exists;
using boost::asio::socket_base;
using boost::asio::static_thread_pool;
using boost::asio::steady_timer;
using boost::asio::system_context;
using boost::asio::system_executor;
using boost::asio::thread_pool;
using boost::asio::ip::address;
using boost::asio::append;
using boost::asio::as_tuple;
using boost::asio::async_compose;
using boost::asio::bind_cancellation_slot;
using boost::asio::cancel_after;
using boost::asio::consign;
using boost::asio::default_completion_token_t;
using boost::asio::detached;
using boost::asio::enable_terminal_cancellation;
using boost::asio::enable_total_cancellation;
using boost::asio::make_strand;
using boost::asio::signal_set;
// --- Error handling subnamespace ---namespace error {
using boost::asio::error::make_error_code;
}
// --- Coroutine related subnamespace ---namespace this_coro {
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::this_coro::
    cancellation_state_t cancellation_state;
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::this_coro::executor_t
    executor;
// using boost::asio::this_coro::cancellation_state;
// using boost::asio::this_coro::executor;
using boost::asio::this_coro::reset_cancellation_state;
using boost::asio::this_coro::throw_if_cancelled;
} // namespace this_coro
// ======================== Encapsulation use_awaitable ================================#if defined(GENERATING_DOCUMENTATION)
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::use_awaitable_t&lt;&gt;
    use_awaitable;
#else
BOOST_ASIO_INLINE_VARIABLE constexpr boost::asio::use_awaitable_t&lt;&gt;
    use_awaitable(0, 0, 0);
#endif
// =========================== Network support ========================namespace net {
namespace ip {
address make_address(const std::string &amp;str) {
  return boost::asio::ip::make_address(str);
}
} // namespace ip
// --- TCP protocol implementation ---namespace tcp {
using boost::asio::ip::tcp::socket::shutdown_send;
// Use the tcp classusing protocol = boost::asio::ip::tcp;
// Core socket typetemplate &lt;typename Protocol = protocol&gt;
using basic_socket = boost::asio::basic_socket&lt;Protocol&gt;;
template &lt;typename Protocol = protocol&gt;
using basic_socket_acceptor = boost::asio::basic_socket_acceptor&lt;Protocol&gt;;
template &lt;typename Protocol = protocol&gt;
using basic_stream_socket = boost::asio::basic_stream_socket&lt;Protocol&gt;;
template &lt;typename Protocol = protocol&gt;
using basic_resolver = boost::asio::ip::basic_resolver&lt;Protocol&gt;;
// Predefined instanceusing socket = basic_stream_socket&lt;protocol&gt;;
using acceptor = basic_socket_acceptor&lt;protocol&gt;;
using endpoint = boost::asio::ip::basic_endpoint&lt;protocol&gt;;
using resolver = basic_resolver&lt;protocol&gt;;
using resolver_query = boost::asio::ip::basic_resolver_query&lt;protocol&gt;;
using resolver_results = boost::asio::ip::basic_resolver_results&lt;protocol&gt;;
// Factory functioninline socket make_socket(io_context &amp;ctx) { return socket(ctx); }
inline acceptor make_acceptor(io_context &amp;ctx, const endpoint &amp;ep) {
  acceptor a(ctx);
  (());
  a.set_option(socket_base::reuse_address(true));
  (ep);
  ();
  return a;
}
// Enhanced operation functionstemplate &lt;typename Protocol, typename... Args&gt;
auto async_connect(basic_stream_socket&lt;Protocol&gt; &amp;sock, Args &amp;&amp;...args) {
  return boost::asio::async_connect(sock, std::forward&lt;Args&gt;(args)...);
}
// Encapsulation async_read_untiltemplate &lt;typename AsyncReadStream, typename DynamicBuffer,
          typename CompletionToken&gt;
auto async_read_until(AsyncReadStream &amp;stream, DynamicBuffer &amp;&amp;buffer,
                      const std::string &amp;delim, CompletionToken &amp;&amp;token) {
  return boost::asio::async_read_until(
      stream, std::forward&lt;DynamicBuffer&gt;(buffer), delim,
      std::forward&lt;CompletionToken&gt;(token));
}
// Encapsulation async_writetemplate &lt;typename AsyncWriteStream, typename ConstBufferSequence,
          typename CompletionToken&gt;
auto async_write(AsyncWriteStream &amp;stream, const ConstBufferSequence &amp;buffers,
                 CompletionToken &amp;&amp;token) {
  return boost::asio::async_write(stream, buffers,
                                  std::forward&lt;CompletionToken&gt;(token));
}
// Export no_delay option#if defined(GENERATING_DOCUMENTATION)
typedef implementation_defined no_delay;
#else
typedef boost::asio::detail::socket_option::boolean&lt;
    BOOST_ASIO_OS_DEF(IPPROTO_TCP), BOOST_ASIO_OS_DEF(TCP_NODELAY)&gt;
    no_delay;
#endif
} // namespace tcp
// --- UDP protocol implementation ---namespace udp {
using protocol = boost::asio::ip::udp;
template &lt;typename Protocol = protocol&gt;
using basic_socket = boost::asio::basic_socket&lt;Protocol&gt;;
template &lt;typename Protocol = protocol&gt;
using basic_endpoint = boost::asio::ip::basic_endpoint&lt;Protocol&gt;;
using socket = basic_socket&lt;protocol&gt;;
using endpoint = basic_endpoint&lt;protocol&gt;;
} // namespace udp
} // namespace net
// ======================== SSL/TLS Support ===========================namespace ssl {
using boost::asio::ssl::context;
using boost::asio::ssl::context_base;
using boost::asio::ssl::host_name_verification;
using boost::asio::ssl::stream;
using boost::asio::ssl::stream_base;
using boost::asio::ssl::verify_context;
// SSL over TCP specialization typetemplate &lt;typename Protocol = net::tcp::protocol&gt;
using ssl_socket = stream&lt;net::tcp::basic_stream_socket&lt;Protocol&gt;&gt;;
// SSL factory functiontemplate &lt;typename Protocol&gt;
ssl_socket&lt;Protocol&gt;
make_ssl_socket(net::tcp::basic_stream_socket&lt;Protocol&gt; &amp;sock, context &amp;ctx) {
  return ssl_socket&lt;Protocol&gt;(std::move(sock), ctx);
}
// SSL error handlingnamespace error {
using boost::asio::ssl::error::make_error_code;
using boost::asio::ssl::error::stream_errors;
} // namespace error
} // namespace ssl
} // namespace asio
// =============================================================export namespace beast {
// --- Core component export ---using boost::beast::error_code;
using boost::beast::file_mode;
using boost::beast::flat_buffer;
using boost::beast::role_type;
using boost::beast::string_view;
using boost::beast::tcp_stream;
using boost::beast::buffers_to_string;
using boost::beast::get_lowest_layer;
// --- HTTP support ---namespace http {
using boost::beast::http::dynamic_body;
using boost::beast::http::empty_body;
using boost::beast::http::field;
using boost::beast::http::file_body;
using boost::beast::http::request;
using boost::beast::http::response;
using boost::beast::http::status;
using boost::beast::http::string_body;
using boost::beast::http::verb;
using boost::beast::http::basic_fields;
using boost::beast::http::request_parser;
// HTTP factory functiontemplate &lt;typename Body = string_body,
          typename Fields = boost::beast::http::fields&gt;
auto make_request(verb method, std::string target, unsigned version = 11) {
  return request&lt;Body, Fields&gt;(method, target, version);
}
// HTTP asynchronous operationtemplate &lt;typename Stream, typename Request, typename CompletionToken&gt;
auto async_write(Stream &amp;stream, Request &amp;&amp;req, CompletionToken &amp;&amp;token) {
  return boost::beast::http::async_write(stream, std::forward&lt;Request&gt;(req),
                                         std::forward&lt;CompletionToken&gt;(token));
}
template &lt;typename Stream, typename Request&gt;
auto async_write(Stream &amp;stream, Request &amp;&amp;req) {
  return boost::beast::http::async_write(stream, std::forward&lt;Request&gt;(req),
                                         asio::use_awaitable);
}
template &lt;typename Stream, typename Response, typename CompletionToken&gt;
auto async_read(Stream &amp;stream, flat_buffer &amp;buffer, Response &amp;res,
                CompletionToken &amp;&amp;token) {
  return boost::beast::http::async_read(stream, buffer, res,
                                        std::forward&lt;CompletionToken&gt;(token));
}
template &lt;typename Stream, typename Response&gt;
auto async_read(Stream &amp;stream, flat_buffer &amp;buffer, Response &amp;res) {
  return boost::beast::http::async_read(stream, buffer, res,
                                        asio::use_awaitable);
}
} // namespace http
// --- WebSocket Support ---namespace websocket {
using boost::beast::role_type;
using boost::beast::websocket::close_code;
using boost::beast::websocket::is_upgrade;
using boost::beast::websocket::request_type;
using boost::beast::websocket::response_type;
using boost::beast::websocket::stream;
using boost::beast::websocket::stream_base;
// WebSocket factory functiontemplate &lt;typename NextLayer&gt;
auto make_websocket_stream(NextLayer &amp;next_layer) {
  return stream&lt;NextLayer&gt;(next_layer);
}
} // namespace websocket
// --- SSL support ---namespace ssl {
using boost::beast::ssl_stream;
// SSL factory functiontemplate &lt;typename Protocol&gt;
auto make_ssl_stream(asio::net::tcp::basic_stream_socket&lt;Protocol&gt; &amp;sock,
                     asio::ssl::context &amp;ctx) {
  return ssl_stream&lt;asio::net::tcp::basic_stream_socket&lt;Protocol&gt;&gt;(
      std::move(sock), ctx);
}
} // namespace ssl
} // namespace beast
// =============================================================export namespace mysql {
using boost::mysql::connection;
using boost::mysql::connection_pool;
using boost::mysql::datetime;
using boost::mysql::diagnostics;
using boost::mysql::error_code;
using boost::mysql::handshake_params;
using boost::mysql::pool_params;
using boost::mysql::pooled_connection;
using boost::mysql::results;
using boost::mysql::row_view;
using boost::mysql::ssl_mode;
using boost::mysql::statement;
using boost::mysql::tcp_ssl_connection;
using boost::mysql::with_params;
// MySQL factory functionsinline auto
make_connection(connection&lt;connection&lt;boost::asio::ssl::stream&lt;
                    boost::asio::basic_stream_socket&lt;boost::asio::ip::tcp&gt;&gt;&gt;&gt;
                    ctx) {
  return connection&lt;tcp_ssl_connection&gt;(std::move(ctx));
}
// MySQL asynchronous operationtemplate &lt;typename CompletionToken&gt;
auto async_connect(connection&lt;tcp_ssl_connection&gt; &amp;conn,
                   const std::string &amp;host, const std::string &amp;user,
                   const std::string &amp;password, const std::string &amp;database,
                   CompletionToken &amp;&amp;token) {
  return conn.async_connect(host, user, password, database,
                            std::forward&lt;CompletionToken&gt;(token));
}
template &lt;typename CompletionToken&gt;
auto async_execute(connection&lt;tcp_ssl_connection&gt; &amp;conn,
                   const std::string &amp;query, results &amp;result,
                   CompletionToken &amp;&amp;token) {
  return conn.async_execute(query, result,
                            std::forward&lt;CompletionToken&gt;(token));
}
} // namespace mysql
// =============================================================export namespace redis {
using boost::redis::connection;
using boost::redis::request;
using boost::redis::response;
// Redis factory functioninline auto make_connection(asio::io_context &amp;ctx) { return connection(ctx); }
// Redis asynchronous operationtemplate &lt;typename CompletionToken&gt;
auto async_execute(connection &amp;conn, const request &amp;req,
                   boost::redis::response&lt;boost::redis::ignore_t&gt; &amp;res,
                   CompletionToken &amp;&amp;token) {
  return conn.async_exec(req, res, std::forward&lt;CompletionToken&gt;(token));
}
} // namespace redis
export namespace boost {
namespace json {
using boost::json::array;
using boost::json::object;
using boost::json::parse;
using boost::json::serialize;
using boost::json::value;
} // namespace json
} // namespace boost

Code explanation:

importStatement: UseimportStatements are imported into the Boost module, which can avoid some problems contained in traditional header files.
Using the Boost library:existmainIn the functions, we demonstrate how to use the \ and \ libraries.

Things to note

Module availability: Make sure that the version of Boost you installed supports C++20 Modules, and some older versions may not.
Compile options: Different compilers may support C++20 Modules, and the compilation options need to be adjusted according to actual conditions.

Summarize

By using C++20 Modules to import Boost modules, we can improve compilation efficiency and reduce the problems caused by duplicate inclusion of header files. At the same time, with the rich features of the Boost library, we can develop C++ applications more efficiently. I hope this article can help you import Boost modules smoothly using C++20 Modules.

The above is the detailed method of using C++20 Modules to import Boost modules. If you encounter any problems during the practice, please leave a message in the comment area to discuss.

My project case address: /yudaichen/coroutine_blog

This is the article about how to import Boost modules using C++20 Modules. For more related contents of C++ import Boost modules, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!