diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000000..ae4702b670 --- /dev/null +++ b/.clang-format @@ -0,0 +1,83 @@ +--- +# We'll use defaults from the Mozilla style, +# with 2 columns indentation. +BasedOnStyle: Mozilla +#TBD ContinuationIndentWidth: 4 +#TBD IndentPPDirectives: AfterHash +IndentCaseLabels: false +UseTab: Never +--- +Language: Cpp +# AccessModifierOffset: -4 +### see BinPack... too +#XXX not yet possible with clang-format V7.0.1! CK +#XXX AllowAllArgumentsOnNextLine: true +#XXX AllowAllConstructorInitializersOnNextLine: true +#XXX AllowShortLambdasOnASingleLine: None +# +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +#TBD AllowShortFunctionsOnASingleLine: None +# AllowShortFunctionsOnASingleLine: Inline +AllowShortFunctionsOnASingleLine: All +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +# +### Force pointers NOT to the type for C++. +# DerivePointerAlignment: false +# PointerAlignment: Right +#NO! SpaceBeforeCpp11BracedList: true +Cpp11BracedListStyle: true +FixNamespaceComments: true +# +BreakBeforeBraces: Custom +BraceWrapping: + AfterClass: true + AfterControlStatement: true + AfterEnum: false + AfterFunction: true + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: true + AfterUnion: true + AfterExternBlock: true + BeforeCatch: true + BeforeElse: true + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +# +### BinPack... args will all be on the same line +BinPackArguments: true +BinPackParameters: true +# +# from LLVM style: +###TODO We use only 80 columns! +ColumnLimit: 80 +# +#default: AllowAllParametersOfDeclarationOnNextLine: false +# AlwaysBreakTemplateDeclarations: MultiLine +#FIXME BreakBeforeInheritanceComma: false +BreakBeforeInheritanceComma: true +BreakConstructorInitializers: BeforeColon +BreakInheritanceList: BeforeColon +# PenaltyReturnTypeOnItsOwnLine: 60 +# SpaceAfterTemplateKeyword: true +# +IncludeBlocks: Regroup +IncludeCategories: + - Regex: '^("asio.*|)' + Priority: 2 + - Regex: '^<(Poco|gsl|doctest|zmqpp|boost|gtest|gmock|fmt|json|openssl)/' + Priority: 3 + - Regex: '<[[:alnum:].]+>' + Priority: 4 +# all other headers first! + - Regex: '.*' + Priority: 1 +IncludeIsMainRegex: '(_test)?$' +# +--- diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000000..a2ac731121 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,26 @@ +--- +Checks: "-*,\ +cert-*,\ +misc-*,\ +modernize-*,\ +-modernize-raw-string-literal,\ +-modernize-return-braced-init-list,\ +-modernize-use-auto,\ +-modernize-use-equals-default,\ +-modernize-use-equals-delete,\ +-modernize-use-default-member-init,\ +-modernize-use-nullptr,\ +-modernize-use-using,\ +performance-*,\ +readability-*,\ +-readability-named-parameter,\ +-readability-braces-around-statements,\ +-readability-implicit-bool-conversion,\ +-readability-else-after-return,\ +cppcoreguidelines-*,\ +-cppcoreguidelines-owning-memory,\ +-cppcoreguidelines-special-member-functions,\ +-cppcoreguidelines-pro-*\ +" +HeaderFilterRegex: '.*' +... diff --git a/asio/CMakeLists.txt b/asio/CMakeLists.txt new file mode 100644 index 0000000000..1c0f744883 --- /dev/null +++ b/asio/CMakeLists.txt @@ -0,0 +1,240 @@ +# Minimum supported CMake version +cmake_minimum_required(VERSION 3.13 FATAL_ERROR) + +if(CONAN_COMPILER) + + # ========================================================== + project(asio VERSION ${CONAN_PACKAGE_VERSION} LANGUAGES CXX) + # ========================================================== + + include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) + conan_basic_setup(TARGETS) # this set CONAN_TARGETS + +else() + + # use ccache and clang++ if found + find_program(CCACHE_EXECUTABLE "ccache" HINTS /usr/local/bin /opt/local/bin) + if(CCACHE_EXECUTABLE) + message(STATUS "use ccache") + set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE) + set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_EXECUTABLE}" CACHE PATH "ccache" FORCE) + endif() + + # ======================================== + project(asio VERSION 1.14.1 LANGUAGES CXX) + # ======================================== + +endif() + +#---------------------------------------------------------- +# Compiler config +#---------------------------------------------------------- +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 17) + set(CMAKE_CXX_STANDARD_REQUIRED ON) + set(CMAKE_CXX_EXTENSIONS OFF) +endif() +message(STATUS "USING: CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}") +message(STATUS "USING: CMAKE_CXX_STANDARD_REQUIRED=${CMAKE_CXX_STANDARD_REQUIRED}") +message(STATUS "USING: CMAKE_CXX_EXTENSIONS=${CMAKE_CXX_EXTENSIONS}") + + +########################################################### +option(ASIO_STANDALONE "Build asio without boost" ON) +########################################################### +if(ASIO_STANDALONE) + option(COMPILER_WARNINGS_ARE_ERRORS "To be pedantic! ;-)" ON) + if(COMPILER_WARNINGS_ARE_ERRORS) + if(MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) + else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -Wpedantic -Werror) + endif() + endif() +else() + unset(COMPILER_WARNINGS_ARE_ERRORS CACHE) +endif() +########################################################### + + +# ========================================================= +# ASIO Options +#========================================================== +option(ASIO_NO_DEPRECATED "Build asio without deprecated interfaces" ON) +option(ASIO_BUILD_TESTS "Build asio unittest too" OFF) +option(ASIO_BUILD_EXAMPLES "Build asio examples too" OFF) +option(ASIO_ENABLE_HANDLER_TRACKING "enable handler tracking" OFF) +option(ASIO_DISABLE_KQUEUE "disable kqueue" OFF) +option(ASIO_DISABLE_EPOLL "disable epoll" OFF) +option(ASIO_USE_CLANG_TIDY "use clang-tidy if found" OFF) + + +# +# Where to put all the RUNTIME targets when built. This variable is used +# to initialize the RUNTIME_OUTPUT_DIRECTORY property on all the targets. +# +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin) +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib) +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib) + + +set(CPPdefinitions) +set(EXTRA_LIBS) + +if(NOT CONAN_COMPILER AND WIN32) + list(APPEND CPPdefinitions _WIN32_WINNT=0x0501 __USE_W32_SOCKETS + ASIO_HAS_VARIADIC_TEMPLATES ASIO_DISABLE_CONSTEXPR + ) + set(EXTRA_LIBS wsock32 ws2_32) +else() + set(EXTRA_LIBS ${CONAN_TARGETS}) +endif() + +if(NOT CONAN_COMPILER AND ${CMAKE_HOST_SYSTEM_NAME} MATCHES "MINGW.*") + list(APPEND CPPdefinitions _WIN32_WINNT=0x0501 __USE_W32_SOCKETS) +endif() + + +if(ASIO_NO_DEPRECATED) + message(STATUS "disable deprected interfaces") + list(APPEND CPPdefinitions ASIO_NO_DEPRECATED) +endif() + +if(ASIO_ENABLE_HANDLER_TRACKING) + message(STATUS "enable handler tracking") + list(APPEND CPPdefinitions ASIO_ENABLE_HANDLER_TRACKING) +endif() + +if(ASIO_DISABLE_KQUEUE) + message(STATUS "disble queue") + list(APPEND CPPdefinitions ASIO_DISABLE_KQUEUE) +endif() + +if(ASIO_DISABLE_EPOLL) + message(STATUS "disable epoll") + list(APPEND CPPdefinitions ASIO_DISABLE_EPOLL) +endif() + +if(ASIO_USE_CLANG_TIDY) + message(STATUS "use clang-tidy") + find_program(CMAKE_CXX_CLANG_TIDY + NAMES clang-tidy clang-tidy-8 clang-tidy-9 clang-tidy-7 + HINTS /usr/local/bin /opt/local/bin + ) +else() + unset(CMAKE_CXX_CLANG_TIDY CACHE) +endif() + +if(NOT CONAN_COMPILER) + if(NOT ASIO_STANDALONE) + ##################################################################### + # use boost if found + option(Boost_USE_MULTITHREADED "Set to OFF to use the non-multithreaded" ON) + option(Boost_DEBUG "Set to ON to enable debug output from FindBoost." OFF) + option(Boost_DETAILED_FAILURE_MSG "Set to ON to get detailed information" ON) + # Set Boost_NO_BOOST_CMAKE to ON to disable the search for boost-cmake. + set(Boost_NO_BOOST_CMAKE ON) + set(BOOST_ROOT "/opt/local" CACHE PATH "path to the boost lib") + set(Boost_USE_STATIC_LIBS OFF) + if(WIN32) + set(Boost_USE_STATIC_RUNTIME OFF) + endif() + find_package(Boost 1.67 + COMPONENTS atomic chrono coroutine context thread system + ) + ##################################################################### + + if(Boost_FOUND) + include_directories(${Boost_INCLUDE_DIRS}) + link_directories(${Boost_LIBRARY_DIRS}) + list(APPEND CPPdefinitions BOOST_ALL_NO_LIB=1 + BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING + ) + list(APPEND EXTRA_LIBS ${Boost_LIBRARIES}) + endif() + ##################################################################### + endif() + + + ####################################################################### + # use openssl if found + set(OPENSSL_ROOT_DIR "/usr" CACHE PATH "path to the openssl lib") + find_package(OpenSSL HINTS ${OPENSSL_ROOT_DIR} /opt/local) + ####################################################################### + + if(OpenSSL_FOUND) + list(APPEND EXTRA_LIBS ${openSSL_LIBRARIES}) + message(STATUS "HAVE_OPENSSL") + list(APPEND CPPdefinitions HAVE_OPENSSL) + include_directories(BEFORE ${openSSL_INCLUDE_DIR}) + # else() + # find_library(OpenSSL_LIBRARY ssl HINTS ${OpenSSL_ROOT_DIR}/lib) + # find_library(CRYPTO_LIBRARY crypto HINTS ${OpenSSL_ROOT_DIR}/lib) + # if(OpenSSL_LIBRARY AND CRYPTO_LIBRARY) + # set(OpenSSL_FOUND ON) + # message(STATUS "USE CRYPTO_LIBRARY") + # list(APPEND CPPdefinitions HAVE_OPENSSL) + # list(APPEND EXTRA_LIBS ${OpenSSL_LIBRARY} ${CRYPTO_LIBRARY}) + # include_directories(BEFORE ${OpenSSL_ROOT_DIR}/include) + # endif() + endif() + ####################################################################### +else() + message(STATUS "ASIO USE CONAN_TARGETS") + if(CONAN_LIBS_OPENSSL) + list(APPEND CPPdefinitions HAVE_OPENSSL) + message(STATUS "have CONAN_LIBS_OPENSSL") + endif() +endif() + + +if(UNIX) + find_library(PTHREAD_LIBRARY pthread REQUIRED) + message(STATUS "USE ${PTHREAD_LIBRARY}") + list(APPEND EXTRA_LIBS ${PTHREAD_LIBRARY}) +endif() + +message(STATUS "CPPdefinitions:${CPPdefinitions}") + + +# Installation configuration +include(GNUInstallDirs) +set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/asio) + +# Interface library +add_subdirectory(include) + + +if($ENV{CONAN_RUN_TESTS}) + set(ASIO_BUILD_TESTS ON CACHE BOOL "" FORCE) + message(STATUS "ASIO CONAN_RUN_TESTS") +endif() + + +if(ASIO_BUILD_EXAMPLES OR ASIO_BUILD_TESTS) + # enable ctest + enable_testing() + + # Sources: examples, tests + add_subdirectory(src) +endif() + + +# Installation +include(CMakePackageConfigHelpers) +configure_package_config_file(asio-config.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/asio-config.cmake + INSTALL_DESTINATION ${ConfigPackageLocation}) +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/asio-config-version.cmake + VERSION ${asio_VERSION} + COMPATIBILITY SameMajorVersion) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/asio-config-version.cmake + ${CMAKE_CURRENT_BINARY_DIR}/asio-config.cmake + DESTINATION ${ConfigPackageLocation}) +install(EXPORT asio-targets + DESTINATION ${ConfigPackageLocation} + NAMESPACE asio::) + diff --git a/asio/asio-config.cmake.in b/asio/asio-config.cmake.in new file mode 100644 index 0000000000..974b352e45 --- /dev/null +++ b/asio/asio-config.cmake.in @@ -0,0 +1,7 @@ +@PACKAGE_INIT@ + +include(${CMAKE_CURRENT_LIST_DIR}/asio-targets.cmake) +check_required_components(asio) + +include(CMakeFindDependencyMacro) +find_dependency(OpenSSL QUIET) diff --git a/asio/include/CMakeLists.txt b/asio/include/CMakeLists.txt new file mode 100644 index 0000000000..36e6fe9616 --- /dev/null +++ b/asio/include/CMakeLists.txt @@ -0,0 +1,530 @@ +# List of public headers +# find . -name "*.*pp" | sed -e 's/^\.\///' | sed -e 's/^.*\/src.cpp$/#NO! &/' | sort > header-sorted.txt +set(asio_PUBLIC_HEADERS +#NO! asio/impl/src.cpp +asio.hpp +asio/associated_allocator.hpp +asio/associated_executor.hpp +asio/async_result.hpp +asio/awaitable.hpp +asio/basic_datagram_socket.hpp +asio/basic_deadline_timer.hpp +asio/basic_io_object.hpp +asio/basic_raw_socket.hpp +asio/basic_seq_packet_socket.hpp +asio/basic_serial_port.hpp +asio/basic_signal_set.hpp +asio/basic_socket.hpp +asio/basic_socket_acceptor.hpp +asio/basic_socket_iostream.hpp +asio/basic_socket_streambuf.hpp +asio/basic_stream_socket.hpp +asio/basic_streambuf.hpp +asio/basic_streambuf_fwd.hpp +asio/basic_waitable_timer.hpp +asio/bind_executor.hpp +asio/buffer.hpp +asio/buffered_read_stream.hpp +asio/buffered_read_stream_fwd.hpp +asio/buffered_stream.hpp +asio/buffered_stream_fwd.hpp +asio/buffered_write_stream.hpp +asio/buffered_write_stream_fwd.hpp +asio/buffers_iterator.hpp +asio/co_spawn.hpp +asio/completion_condition.hpp +asio/compose.hpp +asio/connect.hpp +asio/coroutine.hpp +asio/deadline_timer.hpp +asio/defer.hpp +asio/detached.hpp +asio/detail/array.hpp +asio/detail/array_fwd.hpp +asio/detail/assert.hpp +asio/detail/atomic_count.hpp +asio/detail/base_from_completion_cond.hpp +asio/detail/bind_handler.hpp +asio/detail/buffer_resize_guard.hpp +asio/detail/buffer_sequence_adapter.hpp +asio/detail/buffered_stream_storage.hpp +asio/detail/call_stack.hpp +asio/detail/chrono.hpp +asio/detail/chrono_time_traits.hpp +asio/detail/completion_handler.hpp +asio/detail/concurrency_hint.hpp +asio/detail/conditionally_enabled_event.hpp +asio/detail/conditionally_enabled_mutex.hpp +asio/detail/config.hpp +asio/detail/consuming_buffers.hpp +asio/detail/cstddef.hpp +asio/detail/cstdint.hpp +asio/detail/date_time_fwd.hpp +asio/detail/deadline_timer_service.hpp +asio/detail/dependent_type.hpp +asio/detail/descriptor_ops.hpp +asio/detail/descriptor_read_op.hpp +asio/detail/descriptor_write_op.hpp +asio/detail/dev_poll_reactor.hpp +asio/detail/epoll_reactor.hpp +asio/detail/event.hpp +asio/detail/eventfd_select_interrupter.hpp +asio/detail/executor_function.hpp +asio/detail/executor_op.hpp +asio/detail/fd_set_adapter.hpp +asio/detail/fenced_block.hpp +asio/detail/functional.hpp +asio/detail/future.hpp +asio/detail/gcc_arm_fenced_block.hpp +asio/detail/gcc_hppa_fenced_block.hpp +asio/detail/gcc_sync_fenced_block.hpp +asio/detail/gcc_x86_fenced_block.hpp +asio/detail/global.hpp +asio/detail/handler_alloc_helpers.hpp +asio/detail/handler_cont_helpers.hpp +asio/detail/handler_invoke_helpers.hpp +asio/detail/handler_tracking.hpp +asio/detail/handler_type_requirements.hpp +asio/detail/handler_work.hpp +asio/detail/hash_map.hpp +asio/detail/impl/buffer_sequence_adapter.ipp +asio/detail/impl/descriptor_ops.ipp +asio/detail/impl/dev_poll_reactor.hpp +asio/detail/impl/dev_poll_reactor.ipp +asio/detail/impl/epoll_reactor.hpp +asio/detail/impl/epoll_reactor.ipp +asio/detail/impl/eventfd_select_interrupter.ipp +asio/detail/impl/handler_tracking.ipp +asio/detail/impl/kqueue_reactor.hpp +asio/detail/impl/kqueue_reactor.ipp +asio/detail/impl/null_event.ipp +asio/detail/impl/pipe_select_interrupter.ipp +asio/detail/impl/posix_event.ipp +asio/detail/impl/posix_mutex.ipp +asio/detail/impl/posix_thread.ipp +asio/detail/impl/posix_tss_ptr.ipp +asio/detail/impl/reactive_descriptor_service.ipp +asio/detail/impl/reactive_serial_port_service.ipp +asio/detail/impl/reactive_socket_service_base.ipp +asio/detail/impl/resolver_service_base.ipp +asio/detail/impl/scheduler.ipp +asio/detail/impl/select_reactor.hpp +asio/detail/impl/select_reactor.ipp +asio/detail/impl/service_registry.hpp +asio/detail/impl/service_registry.ipp +asio/detail/impl/signal_set_service.ipp +asio/detail/impl/socket_ops.ipp +asio/detail/impl/socket_select_interrupter.ipp +asio/detail/impl/strand_executor_service.hpp +asio/detail/impl/strand_executor_service.ipp +asio/detail/impl/strand_service.hpp +asio/detail/impl/strand_service.ipp +asio/detail/impl/throw_error.ipp +asio/detail/impl/timer_queue_ptime.ipp +asio/detail/impl/timer_queue_set.ipp +asio/detail/impl/win_event.ipp +asio/detail/impl/win_iocp_handle_service.ipp +asio/detail/impl/win_iocp_io_context.hpp +asio/detail/impl/win_iocp_io_context.ipp +asio/detail/impl/win_iocp_serial_port_service.ipp +asio/detail/impl/win_iocp_socket_service_base.ipp +asio/detail/impl/win_mutex.ipp +asio/detail/impl/win_object_handle_service.ipp +asio/detail/impl/win_static_mutex.ipp +asio/detail/impl/win_thread.ipp +asio/detail/impl/win_tss_ptr.ipp +asio/detail/impl/winrt_ssocket_service_base.ipp +asio/detail/impl/winrt_timer_scheduler.hpp +asio/detail/impl/winrt_timer_scheduler.ipp +asio/detail/impl/winsock_init.ipp +asio/detail/io_control.hpp +asio/detail/io_object_executor.hpp +asio/detail/io_object_impl.hpp +asio/detail/is_buffer_sequence.hpp +asio/detail/is_executor.hpp +asio/detail/keyword_tss_ptr.hpp +asio/detail/kqueue_reactor.hpp +asio/detail/limits.hpp +asio/detail/local_free_on_block_exit.hpp +asio/detail/macos_fenced_block.hpp +asio/detail/memory.hpp +asio/detail/mutex.hpp +asio/detail/non_const_lvalue.hpp +asio/detail/noncopyable.hpp +asio/detail/null_event.hpp +asio/detail/null_fenced_block.hpp +asio/detail/null_global.hpp +asio/detail/null_mutex.hpp +asio/detail/null_reactor.hpp +asio/detail/null_signal_blocker.hpp +asio/detail/null_socket_service.hpp +asio/detail/null_static_mutex.hpp +asio/detail/null_thread.hpp +asio/detail/null_tss_ptr.hpp +asio/detail/object_pool.hpp +asio/detail/old_win_sdk_compat.hpp +asio/detail/op_queue.hpp +asio/detail/operation.hpp +asio/detail/pipe_select_interrupter.hpp +asio/detail/pop_options.hpp +asio/detail/posix_event.hpp +asio/detail/posix_fd_set_adapter.hpp +asio/detail/posix_global.hpp +asio/detail/posix_mutex.hpp +asio/detail/posix_signal_blocker.hpp +asio/detail/posix_static_mutex.hpp +asio/detail/posix_thread.hpp +asio/detail/posix_tss_ptr.hpp +asio/detail/push_options.hpp +asio/detail/reactive_descriptor_service.hpp +asio/detail/reactive_null_buffers_op.hpp +asio/detail/reactive_serial_port_service.hpp +asio/detail/reactive_socket_accept_op.hpp +asio/detail/reactive_socket_connect_op.hpp +asio/detail/reactive_socket_recv_op.hpp +asio/detail/reactive_socket_recvfrom_op.hpp +asio/detail/reactive_socket_recvmsg_op.hpp +asio/detail/reactive_socket_send_op.hpp +asio/detail/reactive_socket_sendto_op.hpp +asio/detail/reactive_socket_service.hpp +asio/detail/reactive_socket_service_base.hpp +asio/detail/reactive_wait_op.hpp +asio/detail/reactor.hpp +asio/detail/reactor_fwd.hpp +asio/detail/reactor_op.hpp +asio/detail/reactor_op_queue.hpp +asio/detail/recycling_allocator.hpp +asio/detail/regex_fwd.hpp +asio/detail/resolve_endpoint_op.hpp +asio/detail/resolve_op.hpp +asio/detail/resolve_query_op.hpp +asio/detail/resolver_service.hpp +asio/detail/resolver_service_base.hpp +asio/detail/scheduler.hpp +asio/detail/scheduler_operation.hpp +asio/detail/scheduler_thread_info.hpp +asio/detail/scoped_lock.hpp +asio/detail/scoped_ptr.hpp +asio/detail/select_interrupter.hpp +asio/detail/select_reactor.hpp +asio/detail/service_registry.hpp +asio/detail/signal_blocker.hpp +asio/detail/signal_handler.hpp +asio/detail/signal_init.hpp +asio/detail/signal_op.hpp +asio/detail/signal_set_service.hpp +asio/detail/socket_holder.hpp +asio/detail/socket_ops.hpp +asio/detail/socket_option.hpp +asio/detail/socket_select_interrupter.hpp +asio/detail/socket_types.hpp +asio/detail/solaris_fenced_block.hpp +asio/detail/static_mutex.hpp +asio/detail/std_event.hpp +asio/detail/std_fenced_block.hpp +asio/detail/std_global.hpp +asio/detail/std_mutex.hpp +asio/detail/std_static_mutex.hpp +asio/detail/std_thread.hpp +asio/detail/strand_executor_service.hpp +asio/detail/strand_service.hpp +asio/detail/string_view.hpp +asio/detail/thread.hpp +asio/detail/thread_context.hpp +asio/detail/thread_group.hpp +asio/detail/thread_info_base.hpp +asio/detail/throw_error.hpp +asio/detail/throw_exception.hpp +asio/detail/timer_queue.hpp +asio/detail/timer_queue_base.hpp +asio/detail/timer_queue_ptime.hpp +asio/detail/timer_queue_set.hpp +asio/detail/timer_scheduler.hpp +asio/detail/timer_scheduler_fwd.hpp +asio/detail/tss_ptr.hpp +asio/detail/type_traits.hpp +asio/detail/variadic_templates.hpp +asio/detail/wait_handler.hpp +asio/detail/wait_op.hpp +asio/detail/win_event.hpp +asio/detail/win_fd_set_adapter.hpp +asio/detail/win_fenced_block.hpp +asio/detail/win_global.hpp +asio/detail/win_iocp_handle_read_op.hpp +asio/detail/win_iocp_handle_service.hpp +asio/detail/win_iocp_handle_write_op.hpp +asio/detail/win_iocp_io_context.hpp +asio/detail/win_iocp_null_buffers_op.hpp +asio/detail/win_iocp_operation.hpp +asio/detail/win_iocp_overlapped_op.hpp +asio/detail/win_iocp_overlapped_ptr.hpp +asio/detail/win_iocp_serial_port_service.hpp +asio/detail/win_iocp_socket_accept_op.hpp +asio/detail/win_iocp_socket_connect_op.hpp +asio/detail/win_iocp_socket_recv_op.hpp +asio/detail/win_iocp_socket_recvfrom_op.hpp +asio/detail/win_iocp_socket_recvmsg_op.hpp +asio/detail/win_iocp_socket_send_op.hpp +asio/detail/win_iocp_socket_service.hpp +asio/detail/win_iocp_socket_service_base.hpp +asio/detail/win_iocp_thread_info.hpp +asio/detail/win_iocp_wait_op.hpp +asio/detail/win_mutex.hpp +asio/detail/win_object_handle_service.hpp +asio/detail/win_static_mutex.hpp +asio/detail/win_thread.hpp +asio/detail/win_tss_ptr.hpp +asio/detail/winapp_thread.hpp +asio/detail/wince_thread.hpp +asio/detail/winrt_async_manager.hpp +asio/detail/winrt_async_op.hpp +asio/detail/winrt_resolve_op.hpp +asio/detail/winrt_resolver_service.hpp +asio/detail/winrt_socket_connect_op.hpp +asio/detail/winrt_socket_recv_op.hpp +asio/detail/winrt_socket_send_op.hpp +asio/detail/winrt_ssocket_service.hpp +asio/detail/winrt_ssocket_service_base.hpp +asio/detail/winrt_timer_scheduler.hpp +asio/detail/winrt_utils.hpp +asio/detail/winsock_init.hpp +asio/detail/work_dispatcher.hpp +asio/detail/wrapped_handler.hpp +asio/dispatch.hpp +asio/error.hpp +asio/error_code.hpp +asio/execution_context.hpp +asio/executor.hpp +asio/executor_work_guard.hpp +asio/generic/basic_endpoint.hpp +asio/generic/datagram_protocol.hpp +asio/generic/detail/endpoint.hpp +asio/generic/detail/impl/endpoint.ipp +asio/generic/raw_protocol.hpp +asio/generic/seq_packet_protocol.hpp +asio/generic/stream_protocol.hpp +asio/handler_alloc_hook.hpp +asio/handler_continuation_hook.hpp +asio/handler_invoke_hook.hpp +asio/high_resolution_timer.hpp +asio/impl/awaitable.hpp +asio/impl/buffered_read_stream.hpp +asio/impl/buffered_write_stream.hpp +asio/impl/co_spawn.hpp +asio/impl/compose.hpp +asio/impl/connect.hpp +asio/impl/defer.hpp +asio/impl/detached.hpp +asio/impl/dispatch.hpp +asio/impl/error.ipp +asio/impl/error_code.ipp +asio/impl/execution_context.hpp +asio/impl/execution_context.ipp +asio/impl/executor.hpp +asio/impl/executor.ipp +asio/impl/handler_alloc_hook.ipp +asio/impl/io_context.hpp +asio/impl/io_context.ipp +asio/impl/post.hpp +asio/impl/read.hpp +asio/impl/read_at.hpp +asio/impl/read_until.hpp +asio/impl/redirect_error.hpp +asio/impl/serial_port_base.hpp +asio/impl/serial_port_base.ipp +asio/impl/spawn.hpp +asio/impl/src.hpp +asio/impl/system_context.hpp +asio/impl/system_context.ipp +asio/impl/system_executor.hpp +asio/impl/thread_pool.hpp +asio/impl/thread_pool.ipp +asio/impl/use_awaitable.hpp +asio/impl/use_future.hpp +asio/impl/write.hpp +asio/impl/write_at.hpp +asio/io_context.hpp +asio/io_context_strand.hpp +asio/io_service.hpp +asio/io_service_strand.hpp +asio/ip/address.hpp +asio/ip/address_v4.hpp +asio/ip/address_v4_iterator.hpp +asio/ip/address_v4_range.hpp +asio/ip/address_v6.hpp +asio/ip/address_v6_iterator.hpp +asio/ip/address_v6_range.hpp +asio/ip/bad_address_cast.hpp +asio/ip/basic_endpoint.hpp +asio/ip/basic_resolver.hpp +asio/ip/basic_resolver_entry.hpp +asio/ip/basic_resolver_iterator.hpp +asio/ip/basic_resolver_query.hpp +asio/ip/basic_resolver_results.hpp +asio/ip/detail/endpoint.hpp +asio/ip/detail/impl/endpoint.ipp +asio/ip/detail/socket_option.hpp +asio/ip/host_name.hpp +asio/ip/icmp.hpp +asio/ip/impl/address.hpp +asio/ip/impl/address.ipp +asio/ip/impl/address_v4.hpp +asio/ip/impl/address_v4.ipp +asio/ip/impl/address_v6.hpp +asio/ip/impl/address_v6.ipp +asio/ip/impl/basic_endpoint.hpp +asio/ip/impl/host_name.ipp +asio/ip/impl/network_v4.hpp +asio/ip/impl/network_v4.ipp +asio/ip/impl/network_v6.hpp +asio/ip/impl/network_v6.ipp +asio/ip/multicast.hpp +asio/ip/network_v4.hpp +asio/ip/network_v6.hpp +asio/ip/resolver_base.hpp +asio/ip/resolver_query_base.hpp +asio/ip/tcp.hpp +asio/ip/udp.hpp +asio/ip/unicast.hpp +asio/ip/v6_only.hpp +asio/is_executor.hpp +asio/is_read_buffered.hpp +asio/is_write_buffered.hpp +asio/local/basic_endpoint.hpp +asio/local/connect_pair.hpp +asio/local/datagram_protocol.hpp +asio/local/detail/endpoint.hpp +asio/local/detail/impl/endpoint.ipp +asio/local/stream_protocol.hpp +asio/packaged_task.hpp +asio/placeholders.hpp +asio/posix/basic_descriptor.hpp +asio/posix/basic_stream_descriptor.hpp +asio/posix/descriptor.hpp +asio/posix/descriptor_base.hpp +asio/posix/stream_descriptor.hpp +asio/post.hpp +asio/read.hpp +asio/read_at.hpp +asio/read_until.hpp +asio/redirect_error.hpp +asio/serial_port.hpp +asio/serial_port_base.hpp +asio/signal_set.hpp +asio/socket_base.hpp +asio/spawn.hpp +asio/ssl.hpp +asio/ssl/context.hpp +asio/ssl/context_base.hpp +asio/ssl/detail/buffered_handshake_op.hpp +asio/ssl/detail/engine.hpp +asio/ssl/detail/handshake_op.hpp +asio/ssl/detail/impl/engine.ipp +asio/ssl/detail/impl/openssl_init.ipp +asio/ssl/detail/io.hpp +asio/ssl/detail/openssl_init.hpp +asio/ssl/detail/openssl_types.hpp +asio/ssl/detail/password_callback.hpp +asio/ssl/detail/read_op.hpp +asio/ssl/detail/shutdown_op.hpp +asio/ssl/detail/stream_core.hpp +asio/ssl/detail/verify_callback.hpp +asio/ssl/detail/write_op.hpp +asio/ssl/error.hpp +asio/ssl/impl/context.hpp +asio/ssl/impl/context.ipp +asio/ssl/impl/error.ipp +asio/ssl/impl/rfc2818_verification.ipp +asio/ssl/impl/src.hpp +asio/ssl/rfc2818_verification.hpp +asio/ssl/stream.hpp +asio/ssl/stream_base.hpp +asio/ssl/verify_context.hpp +asio/ssl/verify_mode.hpp +asio/steady_timer.hpp +asio/strand.hpp +asio/streambuf.hpp +asio/system_context.hpp +asio/system_error.hpp +asio/system_executor.hpp +asio/system_timer.hpp +asio/this_coro.hpp +asio/thread.hpp +asio/thread_pool.hpp +asio/time_traits.hpp +asio/ts/buffer.hpp +asio/ts/executor.hpp +asio/ts/internet.hpp +asio/ts/io_context.hpp +asio/ts/net.hpp +asio/ts/netfwd.hpp +asio/ts/socket.hpp +asio/ts/timer.hpp +asio/unyield.hpp +asio/use_awaitable.hpp +asio/use_future.hpp +asio/uses_executor.hpp +asio/version.hpp +asio/wait_traits.hpp +asio/windows/basic_object_handle.hpp +asio/windows/basic_overlapped_handle.hpp +asio/windows/basic_random_access_handle.hpp +asio/windows/basic_stream_handle.hpp +asio/windows/object_handle.hpp +asio/windows/overlapped_handle.hpp +asio/windows/overlapped_ptr.hpp +asio/windows/random_access_handle.hpp +asio/windows/stream_handle.hpp +asio/write.hpp +asio/write_at.hpp +asio/yield.hpp +) + + +option(ASIO_SEPARATE_COMPILATION "build asio lib too" ON) +option(BUILD_SHARED_LIBS "build asio as shared lib" ON) + +if(ASIO_SEPARATE_COMPILATION) + set(libasio_SOURCES ../src/asio.cpp) + if(OpenSSL_FOUND) + set(libasio_SOURCES ${libasio_SOURCES} ../src/asio_ssl.cpp) + endif() + + add_library(asio ${libasio_SOURCES} ${asio_PUBLIC_HEADERS}) + add_library(asio::asio ALIAS asio) + + target_compile_definitions(asio PUBLIC ASIO_SEPARATE_COMPILATION ${CPPdefinitions}) + target_include_directories(asio PUBLIC + $ + $) + if(OpenSSL_FOUND) + target_link_libraries(asio INTERFACE OpenSSL::SSL) + else() + target_link_libraries(asio INTERFACE ${EXTRA_LIBS}) + endif() + + install(TARGETS asio EXPORT asio-targets DESTINATION ${CMAKE_INSTALL_LIBDIR}) +endif() + + +# Standalone library +add_library(standalone INTERFACE) +add_library(asio::standalone ALIAS standalone) + +target_include_directories(standalone INTERFACE + $ + $) +if(Boost_FOUND AND NOT ASIO_STANDALONE) + target_compile_definitions(standalone INTERFACE ${CPPdefinitions}) +else() + target_compile_definitions(standalone INTERFACE ASIO_STANDALONE ${CPPdefinitions}) +endif() +target_link_libraries(standalone INTERFACE ${EXTRA_LIBS}) + +install(TARGETS standalone EXPORT asio-targets) + +foreach(header ${asio_PUBLIC_HEADERS}) + get_filename_component(path ${header} PATH) + install(FILES ${header} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${path}) +endforeach() + diff --git a/asio/src/CMakeLists.txt b/asio/src/CMakeLists.txt new file mode 100644 index 0000000000..bfa9e333c2 --- /dev/null +++ b/asio/src/CMakeLists.txt @@ -0,0 +1,10 @@ +# build unit tests +if(ASIO_BUILD_TESTS) + add_subdirectory(tests/unit) +endif() + +# Examples +if(ASIO_BUILD_EXAMPLES) + add_subdirectory(examples) +endif() + diff --git a/asio/src/examples/CMakeLists.txt b/asio/src/examples/CMakeLists.txt new file mode 100644 index 0000000000..36c0753385 --- /dev/null +++ b/asio/src/examples/CMakeLists.txt @@ -0,0 +1,49 @@ +# Minimum supported CMake version +cmake_minimum_required(VERSION 3.13 FATAL_ERROR) + +# ================================================= +project(asio_examples VERSION 1.13.0 LANGUAGES CXX) +# ================================================= + +# Options +set(ASIO_BUILD_EXAMPLES_CPP11 ON CACHE BOOL "Build asio C++11 examples") +set(ASIO_BUILD_EXAMPLES_CPP14 ON CACHE BOOL "Build asio C++14 examples") +if(NOT CMAKE_SYSTEM_NAME MATCHES "Darwin") + set(ASIO_BUILD_EXAMPLES_CPP17 ON CACHE BOOL "Build asio C++17 examples") +endif() + +# Check asio targets +if(TARGET standalone) + add_library(asio::standalone ALIAS standalone) + set(ASIO_FOUND TRUE) +endif() + +# Find asio package +if(NOT ASIO_FOUND) + find_package(asio CONFIG REQUIRED) +endif() + +# Installation configuration +include(GNUInstallDirs) + +if(Boost_FOUND) + add_subdirectory(cpp03) +else() + message(WARNING "examples/cpp03 needs boost!") +endif() + +# C++11 only examples +if(ASIO_BUILD_EXAMPLES_CPP11) + add_subdirectory(cpp11) +endif() + +# C++14 only examples +if(ASIO_BUILD_EXAMPLES_CPP14) + add_subdirectory(cpp14) +endif() + +# C++17 only examples +#NOTE: the examples needs COROUTINE! CK +if(ASIO_BUILD_EXAMPLES_CPP17) + add_subdirectory(cpp17) +endif() diff --git a/asio/src/examples/cpp03/CMakeLists.txt b/asio/src/examples/cpp03/CMakeLists.txt new file mode 100644 index 0000000000..23bbf0b832 --- /dev/null +++ b/asio/src/examples/cpp03/CMakeLists.txt @@ -0,0 +1,152 @@ +set(target_prefix asio_cpp03_) + +set(noinst_PROGRAMS + allocation/server + buffers/reference_counted + chat/chat_client + chat/chat_server + echo/async_tcp_echo_server + echo/async_udp_echo_server + echo/blocking_tcp_echo_client + echo/blocking_tcp_echo_server + echo/blocking_udp_echo_client + echo/blocking_udp_echo_server + http/client/async_client + http/client/sync_client + http/server/http_server + http/server2/http_server + http/server3/http_server + http/server4/http_server + icmp/ping + invocation/prioritised_handlers + iostreams/daytime_client + iostreams/daytime_server + iostreams/http_client + multicast/receiver + multicast/sender + nonblocking/third_party_lib + porthopper/client + porthopper/server + services/daytime_client + socks4/sync_client + timeouts/async_tcp_client + timeouts/blocking_tcp_client + timeouts/blocking_udp_client + timeouts/server + timers/time_t_timer + tutorial/timer1/timer + tutorial/timer2/timer + tutorial/timer3/timer + tutorial/timer4/timer + tutorial/timer5/timer + tutorial/daytime1/client + tutorial/daytime2/server + tutorial/daytime3/server + tutorial/daytime4/client + tutorial/daytime5/server + tutorial/daytime6/server + tutorial/daytime7/server +) + +if(OpenSSL_FOUND) + set(noinst_PROGRAMS ${noinst_PROGRAMS} + ssl/client + ssl/server + ) +endif() + +set(allocation_server_SOURCES allocation/server) +set(buffers_reference_counted_SOURCES buffers/reference_counted) +set(chat_chat_client_SOURCES chat/chat_client) +set(chat_chat_server_SOURCES chat/chat_server) +set(echo_async_tcp_echo_server_SOURCES echo/async_tcp_echo_server) +set(echo_async_udp_echo_server_SOURCES echo/async_udp_echo_server) +set(echo_blocking_tcp_echo_client_SOURCES echo/blocking_tcp_echo_client) +set(echo_blocking_tcp_echo_server_SOURCES echo/blocking_tcp_echo_server) +set(echo_blocking_udp_echo_client_SOURCES echo/blocking_udp_echo_client) +set(echo_blocking_udp_echo_server_SOURCES echo/blocking_udp_echo_server) +set(http_client_async_client_SOURCES http/client/async_client) +set(http_client_sync_client_SOURCES http/client/sync_client) +set(http_server_http_server_SOURCES + http/server/connection + http/server/connection_manager + http/server/main + http/server/mime_types + http/server/reply + http/server/request_handler + http/server/request_parser + http/server/server) +set(http_server2_http_server_SOURCES + http/server2/connection + http/server2/io_context_pool + http/server2/main + http/server2/mime_types + http/server2/reply + http/server2/request_handler + http/server2/request_parser + http/server2/server) +set(http_server3_http_server_SOURCES + http/server3/connection + http/server3/main + http/server3/mime_types + http/server3/reply + http/server3/request_handler + http/server3/request_parser + http/server3/server) +set(http_server4_http_server_SOURCES + http/server4/file_handler + http/server4/main + http/server4/mime_types + http/server4/reply + http/server4/request_parser + http/server4/server) +set(icmp_ping_SOURCES icmp/ping) +set(invocation_prioritised_handlers_SOURCES invocation/prioritised_handlers) +set(iostreams_daytime_client_SOURCES iostreams/daytime_client) +set(iostreams_daytime_server_SOURCES iostreams/daytime_server) +set(iostreams_http_client_SOURCES iostreams/http_client) +set(multicast_receiver_SOURCES multicast/receiver) +set(multicast_sender_SOURCES multicast/sender) +set(nonblocking_third_party_lib_SOURCES nonblocking/third_party_lib) +set(porthopper_client_SOURCES porthopper/client) +set(porthopper_server_SOURCES porthopper/server) +set(services_daytime_client_SOURCES + services/daytime_client + services/logger_service) +set(socks4_sync_client_SOURCES socks4/sync_client) +set(timeouts_async_tcp_client_SOURCES timeouts/async_tcp_client) +set(timeouts_blocking_tcp_client_SOURCES timeouts/blocking_tcp_client) +set(timeouts_blocking_udp_client_SOURCES timeouts/blocking_udp_client) +set(timeouts_server_SOURCES timeouts/server) +set(timers_time_t_timer_SOURCES timers/time_t_timer) +set(tutorial_timer1_timer_SOURCES tutorial/timer1/timer) +set(tutorial_timer2_timer_SOURCES tutorial/timer2/timer) +set(tutorial_timer3_timer_SOURCES tutorial/timer3/timer) +set(tutorial_timer4_timer_SOURCES tutorial/timer4/timer) +set(tutorial_timer5_timer_SOURCES tutorial/timer5/timer) +set(tutorial_daytime1_client_SOURCES tutorial/daytime1/client) +set(tutorial_daytime2_server_SOURCES tutorial/daytime2/server) +set(tutorial_daytime3_server_SOURCES tutorial/daytime3/server) +set(tutorial_daytime4_client_SOURCES tutorial/daytime4/client) +set(tutorial_daytime5_server_SOURCES tutorial/daytime5/server) +set(tutorial_daytime6_server_SOURCES tutorial/daytime6/server) +set(tutorial_daytime7_server_SOURCES tutorial/daytime7/server) + +set(ssl_client_SOURCES ssl/client) +set(ssl_server_SOURCES ssl/server) + + +foreach(program ${noinst_PROGRAMS}) + string(REPLACE "/" "_" target ${program}) + add_executable(${target_prefix}${target} ${${target}_SOURCES}) + set_target_properties(${target_prefix}${target} PROPERTIES CXX_STANDARD 98 + #FIXME CXX_STANDARD 03 + #cmake error: CXX_STANDARD is set to invalid value '03' + ) + target_link_libraries(${target_prefix}${target} asio::standalone) + + if(EXTRA_LIBS) + target_link_libraries(${target_prefix}${target} ${EXTRA_LIBS}) + endif() +endforeach() + diff --git a/asio/src/examples/cpp11/CMakeLists.txt b/asio/src/examples/cpp11/CMakeLists.txt new file mode 100644 index 0000000000..16570efcfb --- /dev/null +++ b/asio/src/examples/cpp11/CMakeLists.txt @@ -0,0 +1,87 @@ +set(target_prefix asio_cpp11_) + +set(noinst_PROGRAMS + allocation/server + buffers/reference_counted + chat/chat_client + chat/chat_server + echo/async_tcp_echo_server + echo/async_udp_echo_server + echo/blocking_tcp_echo_client + echo/blocking_tcp_echo_server + echo/blocking_udp_echo_client + echo/blocking_udp_echo_server + executors/actor + executors/bank_account_1 + executors/bank_account_2 + executors/fork_join + executors/pipeline + executors/priority_scheduler + fork/daemon + fork/process_per_connection + futures/daytime_client + http/server/http_server + invocation/prioritised_handlers + iostreams/http_client + local/connect_pair + local/iostream_client + local/stream_client + local/stream_server + multicast/receiver + multicast/sender + nonblocking/third_party_lib + operations/composed_1 + operations/composed_2 + operations/composed_3 + operations/composed_4 + operations/composed_5 + operations/composed_6 + operations/composed_7 + operations/composed_8 + socks4/sync_client + timeouts/async_tcp_client + timeouts/blocking_tcp_client + timeouts/blocking_token_tcp_client + timeouts/blocking_udp_client + timeouts/server + timers/time_t_timer +) + +if(Boost_FOUND) + set(noinst_PROGRAMS ${noinst_PROGRAMS} + spawn/echo_server + spawn/parallel_grep + ) +endif() + +if(OpenSSL_FOUND) + set(noinst_PROGRAMS ${noinst_PROGRAMS} + ssl/client + ssl/server + ) +endif() + +set(http_server_http_server_SOURCES + http/server/connection.cpp + http/server/connection_manager.cpp + http/server/main.cpp + http/server/mime_types.cpp + http/server/reply.cpp + http/server/request_handler.cpp + http/server/request_parser.cpp + http/server/server.cpp +) + +foreach(program ${noinst_PROGRAMS}) + string(REPLACE "/" "_" target ${program}) + if(NOT DEFINED "${target}_SOURCES") + set("${target}_SOURCES" ${program}) + endif() + add_executable(${target_prefix}${target} ${${target}_SOURCES}) + set_target_properties(${target_prefix}${target} PROPERTIES CXX_STANDARD 11) + target_link_libraries(${target_prefix}${target} asio::standalone) + + if(EXTRA_LIBS) + target_link_libraries(${target_prefix}${target} ${EXTRA_LIBS}) + endif() +endforeach() diff --git a/asio/src/examples/cpp11/fork/daemon.cpp b/asio/src/examples/cpp11/fork/daemon.cpp index 2191e5eed3..e4c598359e 100644 --- a/asio/src/examples/cpp11/fork/daemon.cpp +++ b/asio/src/examples/cpp11/fork/daemon.cpp @@ -12,6 +12,7 @@ #include #include #include +#include // strerror used #include #include #include @@ -107,7 +108,7 @@ int main() } else { - syslog(LOG_ERR | LOG_USER, "First fork failed: %m"); + syslog(LOG_ERR | LOG_USER, "First fork failed: %s", strerror(errno)); return 1; } } @@ -136,7 +137,7 @@ int main() } else { - syslog(LOG_ERR | LOG_USER, "Second fork failed: %m"); + syslog(LOG_ERR | LOG_USER, "Second fork failed: %s", strerror(errno)); return 1; } } @@ -150,7 +151,7 @@ int main() // We don't want the daemon to have any standard input. if (open("/dev/null", O_RDONLY) < 0) { - syslog(LOG_ERR | LOG_USER, "Unable to open /dev/null: %m"); + syslog(LOG_ERR | LOG_USER, "Unable to open /dev/null: %s", strerror(errno)); return 1; } @@ -160,14 +161,14 @@ int main() const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; if (open(output, flags, mode) < 0) { - syslog(LOG_ERR | LOG_USER, "Unable to open output file %s: %m", output); + syslog(LOG_ERR | LOG_USER, "Unable to open output file %s: %s", output, strerror(errno)); return 1; } // Also send standard error to the same log file. if (dup(1) < 0) { - syslog(LOG_ERR | LOG_USER, "Unable to dup output descriptor: %m"); + syslog(LOG_ERR | LOG_USER, "Unable to dup output descriptor: %s", strerror(errno)); return 1; } diff --git a/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp b/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp index 77b23758a6..b96ea6ac3a 100644 --- a/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp +++ b/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp @@ -9,6 +9,7 @@ // #include "asio.hpp" + #include #include #include @@ -140,7 +141,9 @@ class handler_priority_queue : public asio::execution_context std::priority_queue> handlers_; }; +// //---------------------------------------------------------------------- +// void high_priority_handler(const asio::error_code& /*ec*/, tcp::socket /*socket*/) @@ -166,6 +169,10 @@ struct low_priority_handler } }; +// +//---------------------------------------------------------------------- +// + int main() { asio::io_context io_context; @@ -193,8 +200,8 @@ int main() // The custom invocation hook adds the handlers to the priority queue // rather than executing them from within the poll_one() call. while (io_context.poll_one()) - ; - + { + } pri_queue.execute_all(); } diff --git a/asio/src/examples/cpp11/socks4/sync_client.cpp b/asio/src/examples/cpp11/socks4/sync_client.cpp index 39798cc382..639db8a781 100644 --- a/asio/src/examples/cpp11/socks4/sync_client.cpp +++ b/asio/src/examples/cpp11/socks4/sync_client.cpp @@ -44,6 +44,7 @@ int main(int argc, char* argv[]) // Get an endpoint for the Boost website. This will be passed to the SOCKS // 4 server. Explicitly specify IPv4 since SOCKS 4 does not support IPv6. + auto http_endpoint = *resolver.resolve(tcp::v4(), "www.boost.org", "http").begin(); diff --git a/asio/src/examples/cpp14/CMakeLists.txt b/asio/src/examples/cpp14/CMakeLists.txt new file mode 100644 index 0000000000..d57533b0d1 --- /dev/null +++ b/asio/src/examples/cpp14/CMakeLists.txt @@ -0,0 +1,43 @@ +set(target_prefix asio_cpp14_) + +set(noinst_PROGRAMS + echo/async_tcp_echo_server.cpp + echo/async_udp_echo_server.cpp + echo/blocking_tcp_echo_client.cpp + echo/blocking_tcp_echo_server.cpp + echo/blocking_udp_echo_client.cpp + echo/blocking_udp_echo_server.cpp + executors/actor.cpp + executors/async_1.cpp + executors/async_2.cpp + executors/bank_account_1.cpp + executors/bank_account_2.cpp + executors/fork_join.cpp + executors/pipeline.cpp + executors/priority_scheduler.cpp + iostreams/http_client.cpp + operations/composed_1.cpp + operations/composed_2.cpp + operations/composed_3.cpp + operations/composed_4.cpp + operations/composed_5.cpp + operations/composed_6.cpp + operations/composed_7.cpp + operations/composed_8.cpp +) + +foreach(source ${noinst_PROGRAMS}) + string(REGEX REPLACE "\.cpp$" "" program ${source}) + string(REPLACE "/" "_" target ${program}) + add_executable(${target_prefix}${target} ${program}.cpp) + set_target_properties(${target_prefix}${target} PROPERTIES CXX_STANDARD 14) + + target_link_libraries(${target_prefix}${target} asio::standalone) + if(EXTRA_LIBS) + target_link_libraries(${target_prefix}${target} ${EXTRA_LIBS}) + endif() + + # install(TARGETS ${target_prefix}${target} + # RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +endforeach() + diff --git a/asio/src/examples/cpp17/CMakeLists.txt b/asio/src/examples/cpp17/CMakeLists.txt new file mode 100644 index 0000000000..7427b8de3d --- /dev/null +++ b/asio/src/examples/cpp17/CMakeLists.txt @@ -0,0 +1,33 @@ +set(target_prefix asio_cpp17_) + +set(noinst_PROGRAMS + coroutines_ts/chat_server.cpp + coroutines_ts/echo_server.cpp + coroutines_ts/range_based_for.cpp + coroutines_ts/refactored_echo_server.cpp + coroutines_ts/echo_server_with_default.cpp +) + +include(CheckCXXCompilerFlag) +check_cxx_compiler_flag(-fcoroutines-ts CXX_COMPILER_HAS_COROUTINES) + +if(CXX_COMPILER_HAS_COROUTINES) + find_library(LIB_CPP_EXPERIMENTAL c++) + foreach(source ${noinst_PROGRAMS}) + string(REGEX REPLACE "\.cpp$" "" program ${source}) + string(REPLACE "/" "_" target ${program}) + + add_executable(${target_prefix}${target} ${program}.cpp) + set_target_properties(${target_prefix}${target} PROPERTIES CXX_STANDARD 17) + target_compile_options(${target_prefix}${target} PRIVATE -fcoroutines-ts -stdlib=libc++) + target_link_libraries(${target_prefix}${target} asio::standalone ${LIB_CPP_EXPERIMENTAL}) + + if(EXTRA_LIBS) + target_link_libraries(${target_prefix}${target} ${EXTRA_LIBS}) + endif() + + # install(TARGETS ${target_prefix}${target} + # RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) + endforeach() +endif() + diff --git a/asio/src/tests/unit/CMakeLists.txt b/asio/src/tests/unit/CMakeLists.txt new file mode 100644 index 0000000000..2161641ca9 --- /dev/null +++ b/asio/src/tests/unit/CMakeLists.txt @@ -0,0 +1,160 @@ +set(target_prefix asio_unit_) + +add_library(asio::standalone ALIAS standalone) + +set(test_PROGRAMS + associated_allocator + associated_executor + async_result + awaitable + basic_datagram_socket + basic_deadline_timer + basic_raw_socket + basic_seq_packet_socket + basic_serial_port + basic_signal_set + basic_socket + basic_socket_acceptor + basic_stream_socket + basic_streambuf + basic_waitable_timer + bind_executor + buffered_read_stream + buffered_stream + buffered_write_stream + buffer + buffers_iterator + co_spawn + completion_condition + compose + connect + coroutine + deadline_timer + defer + detached + dispatch + error + execution_context + executor + executor_work_guard + generic/basic_endpoint + generic/datagram_protocol + generic/raw_protocol + generic/seq_packet_protocol + generic/stream_protocol + high_resolution_timer + io_context + io_context_strand + ip/address + ip/address_v4 + ip/address_v4_iterator + ip/address_v4_range + ip/address_v6 + ip/address_v6_iterator + ip/address_v6_range + ip/basic_endpoint + ip/basic_resolver + ip/basic_resolver_entry + ip/basic_resolver_iterator + ip/basic_resolver_query + ip/host_name + ip/icmp + ip/multicast + ip/network_v4 + ip/network_v6 + ip/resolver_query_base + ip/tcp + ip/udp + ip/unicast + ip/v6_only + is_read_buffered + is_write_buffered + local/basic_endpoint + local/connect_pair + local/datagram_protocol + local/stream_protocol + packaged_task + placeholders + posix/basic_descriptor + posix/basic_stream_descriptor + posix/descriptor + posix/descriptor_base + posix/stream_descriptor + post + read + read_at + read_until + redirect_error + serial_port + serial_port_base + signal_set + socket_base + steady_timer + strand + streambuf + system_context + system_executor + system_timer + this_coro + thread + time_traits + ts/buffer + ts/executor + ts/internet + ts/io_context + ts/net + ts/netfwd + ts/socket + ts/timer + use_awaitable + use_future + uses_executor + wait_traits + windows/basic_object_handle + windows/basic_overlapped_handle + windows/basic_random_access_handle + windows/basic_stream_handle + windows/object_handle + windows/overlapped_handle + windows/overlapped_ptr + windows/random_access_handle + windows/stream_handle + write + write_at +) + + +set(test_header + ../latency/high_res_clock.hpp + unit_test.hpp +) + + +if(OpenSSL_FOUND) + set(more_test_PROGRAMS + ssl/context_base + ssl/context + ssl/error + ssl/rfc2818_verification + ssl/stream_base + ssl/stream + ) +endif() + + +### enable_testing() with ctest +foreach(program ${test_PROGRAMS} ${more_test_PROGRAMS}) + string(REPLACE "/" "_" target ${program}) + add_executable(${target_prefix}${target} ${program}.cpp ${test_header}) + set_target_properties(${target_prefix}${target} PROPERTIES CXX_STANDARD 17) + + target_link_libraries(${target_prefix}${target} asio::standalone) + #NOTE: same as: conan_target_link_libraries(${target_prefix}${target}) + if(EXTRA_LIBS) + target_link_libraries(${target_prefix}${target} ${EXTRA_LIBS}) + endif() + + add_test(NAME ${target_prefix}${target} COMMAND "${target_prefix}${target}" + ) +endforeach() + diff --git a/build-with-clang-tidy.log b/build-with-clang-tidy.log new file mode 100644 index 0000000000..2404d49eb9 --- /dev/null +++ b/build-with-clang-tidy.log @@ -0,0 +1,873 @@ +[1/3] Building CXX object include/CMakeFiles/asio.dir/__/src/asio_ssl.cpp.o +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:55:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder1(binder1&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:153:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder2(binder2&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:258:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder3(binder3&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:372:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder4(binder4&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:496:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder5(binder5&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:596:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + move_binder1(move_binder1&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:656:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + move_binder2(move_binder2&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/call_stack.hpp:118:25: warning: initialization of 'top_' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] +call_stack::top_; + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/tss_ptr.hpp:38:7: note: possibly throwing constructor declared here +class tss_ptr + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/service_registry.hpp:58:31: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline void service_registry::init_key( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/posix_thread.hpp:83:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual void run() + ~~~~~~~~~~~~~^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/posix_tss_ptr.hpp:57:3: warning: operator=() should return 'posix_tss_ptr&' [cppcoreguidelines-c-copy-assignment-signature] + void operator=(T* value) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/scheduler.hpp:51:13: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL ~scheduler(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/scheduler.hpp:54:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/socket_types.hpp:87:11: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/thread_info_base.hpp:48:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_mem_index; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : reusable_memory_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/thread_info_base.hpp:54:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_mem_index; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : reusable_memory_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/tss_ptr.hpp:50:3: warning: operator=() should return 'tss_ptr&' [misc-unconventional-assign-operator] + void operator=(T* value) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/wrapped_handler.hpp:66:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + wrapped_handler(wrapped_handler&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/wrapped_handler.hpp:181:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + rewrapped_handler(rewrapped_handler&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:257:3: warning: initialization of 'system_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + system_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:226:36: note: possibly throwing function declared here +inline const asio::error_category& get_system_category() + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:260:3: warning: initialization of 'netdb_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + netdb_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:234:29: note: possibly throwing function declared here +const asio::error_category& get_netdb_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:263:3: warning: initialization of 'addrinfo_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + addrinfo_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:237:29: note: possibly throwing function declared here +const asio::error_category& get_addrinfo_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:266:3: warning: initialization of 'misc_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + misc_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:254:29: note: possibly throwing function declared here +const asio::error_category& get_misc_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:208:19: warning: redundant 'use_service' declaration [readability-redundant-declaration] + friend Service& use_service(execution_context& e); + ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:33:38: note: previously declared here +template Service& use_service(execution_context&); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:225:19: warning: redundant 'use_service' declaration [readability-redundant-declaration] + friend Service& use_service(io_context& ioc); + ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:34:38: note: previously declared here +template Service& use_service(io_context&); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:285:15: warning: redundant 'add_service' declaration [readability-redundant-declaration] + friend void add_service(execution_context& e, Service* svc); + ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:35:34: note: previously declared here +template void add_service(execution_context&, Service*); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:298:15: warning: redundant 'has_service' declaration [readability-redundant-declaration] + friend bool has_service(execution_context& e); + ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:36:34: note: previously declared here +template bool has_service(execution_context&); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/handler_continuation_hook.hpp:45:13: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline bool asio_handler_is_continuation(...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/handler_invoke_hook.hpp:66:13: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline void asio_handler_invoke(Function& function, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/handler_invoke_hook.hpp:73:13: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline void asio_handler_invoke(const Function& function, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:608:19: warning: redundant 'use_service' declaration [readability-redundant-declaration] + friend Service& use_service(io_context& ioc); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:225:19: note: previously declared here + friend Service& use_service(io_context& ioc); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:795:26: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual void shutdown(); + ~~~~~~~~~~~~~^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:809:26: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual void notify_fork( + ~~~~~~~~~~~~~^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:831:21: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual ~service(); + ~~~~~~~~^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/bad_address_cast.hpp:39:11: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual ~bad_address_cast() ASIO_NOEXCEPT_OR_NOTHROW {} + ~~~~~~~~^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/bad_address_cast.hpp:42:23: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual const char* what() const ASIO_NOEXCEPT_OR_NOTHROW + ~~~~~~~~~~~~~~ ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/context.hpp:58:13: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + ASIO_DECL context(context&& other); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/context.hpp:71:22: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor] + ASIO_DECL context& operator=(context&& other); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/detail/impl/openssl_init.ipp:44:5: warning: use range-based for loop instead [modernize-loop-convert] + for (size_t i = 0; i < mutexes_.size(); ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & mutexe : mutexes_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/detail/impl/openssl_init.ipp:45:19: warning: use std::make_shared instead [modernize-make-shared] + mutexes_[i].reset(new asio::detail::mutex); + ~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + = std::make_shared +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/detail/openssl_init.hpp:89:46: warning: initialization of 'instance_' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] +openssl_init openssl_init::instance_; + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/detail/openssl_init.hpp:58:3: note: possibly throwing constructor declared here + openssl_init() + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/detail/password_callback.hpp:50:23: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual std::string call(std::size_t size, + ~~~~~~~~~~~ ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/detail/verify_callback.hpp:47:16: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual bool call(bool preverified, verify_context& ctx) + ~~~~~~~~~~~~~^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/error.hpp:36:3: warning: initialization of 'ssl_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + ssl_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/error.hpp:33:29: note: possibly throwing function declared here +const asio::error_category& get_ssl_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/error.hpp:71:3: warning: initialization of 'stream_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + stream_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/error.hpp:68:29: note: possibly throwing function declared here +const asio::error_category& get_stream_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/impl/context.ipp:370:10: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] +context::context(context&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/impl/context.ipp:376:19: warning: move assignment operators should be marked noexcept [performance-noexcept-move-constructor] +context& context::operator=(context&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/impl/error.ipp:31:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const char* name() const ASIO_ERROR_CATEGORY_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/impl/error.ipp:36:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + std::string message(int value) const + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ssl/rfc2818_verification.hpp:67:33: warning: pass by value and use std::move [modernize-pass-by-value] + explicit rfc2818_verification(const std::string& host) + ^~~~~~~~~~~~~~~~~~ + std::string +/opt/local/include/openssl/asn1.h:62:11: warning: inclusion of deprecated C++ header 'time.h'; consider using 'ctime' instead [modernize-deprecated-headers] +# include + ^~~~~~~~ + +/opt/local/include/openssl/asn1.h:985:34: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x); + ^~~~~ +/opt/local/include/openssl/asn1.h:1013:35: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x); + ^~~~~ +/opt/local/include/openssl/bio.h:65:12: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~ + +/opt/local/include/openssl/bio.h:67:11: warning: inclusion of deprecated C++ header 'stdarg.h'; consider using 'cstdarg' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/bn.h:128:11: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/bn.h:131:12: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead [modernize-deprecated-headers] +# include /* FILE */ + ^~~~~~~~~ + +/opt/local/include/openssl/buffer.h:68:11: warning: inclusion of deprecated C++ header 'stddef.h'; consider using 'cstddef' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/comp.h:31:19: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + long (*ctrl) (void); + ^~~~~ +/opt/local/include/openssl/comp.h:32:28: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + long (*callback_ctrl) (void); + ^~~~~ +/opt/local/include/openssl/crypto.h:120:11: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/crypto.h:125:12: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~ + +/opt/local/include/openssl/crypto.h:462:52: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +void CRYPTO_set_id_callback(unsigned long (*func) (void)); + ^~~~~ +/opt/local/include/openssl/crypto.h:513:48: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] + long (*go) (void)); + ^~~~~ +/opt/local/include/openssl/engine.h:331:37: warning: redundant void argument list in typedef [modernize-redundant-void-arg] +typedef int (*ENGINE_GEN_FUNC_PTR) (void); + ^~~~~ +/opt/local/include/openssl/engine.h:336:49: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] + void (*f) (void)); + ^~~~~ +/opt/local/include/openssl/engine.h:498:65: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)); + ^~~~~ +/opt/local/include/openssl/engine.h:515:49: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] + long i, void *p, void (*f) (void), int cmd_optional); + ^~~~~ +/opt/local/include/openssl/err.h:118:12: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~ + +/opt/local/include/openssl/err.h:119:12: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/err.h:140:11: warning: inclusion of deprecated C++ header 'errno.h'; consider using 'cerrno' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~ + +/opt/local/include/openssl/lhash.h:68:12: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~ + +/opt/local/include/openssl/pqueue.h:63:11: warning: inclusion of deprecated C++ header 'stdio.h'; consider using 'cstdio' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~ + +/opt/local/include/openssl/pqueue.h:64:11: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/pqueue.h:65:11: warning: inclusion of deprecated C++ header 'string.h'; consider using 'cstring' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/rand.h:62:11: warning: inclusion of deprecated C++ header 'stdlib.h'; consider using 'cstdlib' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/rand.h:84:22: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + void (*cleanup) (void); + ^~~~~ +/opt/local/include/openssl/rand.h:87:20: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + int (*status) (void); + ^~~~~ +/opt/local/include/openssl/sha.h:63:11: warning: inclusion of deprecated C++ header 'stddef.h'; consider using 'cstddef' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/opt/local/include/openssl/ssl.h:462:25: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + int (*num_ciphers) (void); + ^~~~~ +/opt/local/include/openssl/ssl.h:465:26: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + long (*get_timeout) (void); + ^~~~~ +/opt/local/include/openssl/ssl.h:467:25: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + int (*ssl_version) (void); + ^~~~~ +/opt/local/include/openssl/ssl.h:468:63: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] + long (*ssl_callback_ctrl) (SSL *s, int cb_id, void (*fp) (void)); + ^~~~~ +/opt/local/include/openssl/ssl.h:469:71: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] + long (*ssl_ctx_callback_ctrl) (SSL_CTX *s, int cb_id, void (*fp) (void)); + ^~~~~ +/opt/local/include/openssl/ssl.h:2338:45: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +long SSL_callback_ctrl(SSL *, int, void (*)(void)); + ^~~~~ +/opt/local/include/openssl/ssl.h:2340:53: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void)); + ^~~~~ +/opt/local/include/openssl/tls1.h:309:46: warning: parameter 'type' is const-qualified in the function declaration; const-qualification of parameters only has an effect in function definitions [readability-avoid-const-params-in-decls] +const char *SSL_get_servername(const SSL *s, const int type); + ^~~~~~~~~~ +/opt/local/include/openssl/ui.h:224:58: warning: redundant void argument list in variable declaration [modernize-redundant-void-arg] +int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void)); + ^~~~~ +/opt/local/include/openssl/x509.h:139:17: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + int (*a2i) (void); + ^~~~~ +/opt/local/include/openssl/x509.h:140:17: warning: redundant void argument list in field declaration [modernize-redundant-void-arg] + int (*i2a) (void); + ^~~~~ +/opt/local/include/openssl/x509v3.h:83:33: warning: redundant void argument list in typedef [modernize-redundant-void-arg] +typedef void *(*X509V3_EXT_NEW)(void); + ^~~~~ +[2/3] Building CXX object include/CMakeFiles/asio.dir/__/src/asio.cpp.o +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:55:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder1(binder1&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:153:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder2(binder2&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:258:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder3(binder3&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:372:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder4(binder4&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:496:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + binder5(binder5&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:596:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + move_binder1(move_binder1&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/bind_handler.hpp:656:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + move_binder2(move_binder2&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/call_stack.hpp:118:25: warning: initialization of 'top_' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] +call_stack::top_; + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/tss_ptr.hpp:38:7: note: possibly throwing constructor declared here +class tss_ptr + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/handler_tracking.ipp:322:24: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +void handler_tracking::write_line(const char* format, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp:48:5: warning: initializer for member 'interrupter_' is redundant [readability-redundant-member-init] + interrupter_(), + ^~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp:78:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_ops; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : state->op_queue_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp:270:3: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_ops; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : descriptor_data->op_queue_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp:311:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_ops; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : descriptor_data->op_queue_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp:361:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_ops; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : descriptor_data->op_queue_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/service_registry.hpp:58:31: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline void service_registry::init_key( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/signal_set_service.ipp:144:3: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_signal_number; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & registration : registrations_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/signal_set_service.ipp:161:3: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_signal_number; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto reg : registrations_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/socket_ops.ipp:2379:21: warning: 'atoi' used to convert a string to an integer value, but function will not report conversion errors; consider using 'strtol' instead [cert-err34-c] + *scope_id = atoi(if_name + 1); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/socket_ops.ipp:3349:47: warning: 'atoi' used to convert a string to an integer value, but function will not report conversion errors; consider using 'strtol' instead [cert-err34-c] + u_short_type port = host_to_network_short(atoi(service)); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/strand_executor_service.hpp:33:11: warning: pass by value and use std::move [modernize-pass-by-value] + invoker(const implementation_type& impl, Executor& ex) + ^~~~~~~~~~~~~~~~~~~~~~~~~~ + implementation_type +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/strand_executor_service.hpp:46:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + invoker(invoker&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/strand_service.ipp:58:3: warning: use range-based for loop instead [modernize-loop-convert] + for (std::size_t i = 0; i < num_implementations; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & implementation : implementations_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/kqueue_reactor.hpp:88:13: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL ~kqueue_reactor(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/kqueue_reactor.hpp:91:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/kqueue_reactor.hpp:94:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void notify_fork( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/posix_signal_blocker.hpp:24:10: warning: inclusion of deprecated C++ header 'signal.h'; consider using 'csignal' instead [modernize-deprecated-headers] +#include + ^~~~~~~~~~ + +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/posix_thread.hpp:83:18: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual void run() + ~~~~~~~~~~~~~^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/posix_tss_ptr.hpp:57:3: warning: operator=() should return 'posix_tss_ptr&' [misc-unconventional-assign-operator] + void operator=(T* value) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/reactive_descriptor_service.hpp:81:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/reactive_serial_port_service.hpp:50:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/scheduler.hpp:51:13: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL ~scheduler(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/scheduler.hpp:54:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/service_registry.hpp:81:15: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] + static void init_key(execution_context::service::key& key, ...); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/signal_set_service.hpp:21:10: warning: inclusion of deprecated C++ header 'signal.h'; consider using 'csignal' instead [modernize-deprecated-headers] +#include + ^~~~~~~~~~ + +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/signal_set_service.hpp:121:13: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL ~signal_set_service(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/signal_set_service.hpp:124:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/signal_set_service.hpp:127:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void notify_fork( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/socket_types.hpp:87:11: warning: inclusion of deprecated C++ header 'limits.h'; consider using 'climits' instead [modernize-deprecated-headers] +# include + ^~~~~~~~~~ + +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/strand_executor_service.hpp:80:22: warning: function 'asio::detail::strand_executor_service::strand_executor_service' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name] + ASIO_DECL explicit strand_executor_service(execution_context& context); + ^ ~~~~~~~~ + ctx +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/impl/strand_executor_service.ipp:26:26: note: the definition seen here +strand_executor_service::strand_executor_service(execution_context& ctx) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/strand_executor_service.hpp:80:22: note: differing parameters are named here: ('context'), in definition: ('ctx') + ASIO_DECL explicit strand_executor_service(execution_context& context); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/strand_executor_service.hpp:83:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/strand_service.hpp:81:18: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + ASIO_DECL void shutdown(); + ^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/thread_info_base.hpp:48:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_mem_index; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : reusable_memory_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/thread_info_base.hpp:54:5: warning: use range-based for loop instead [modernize-loop-convert] + for (int i = 0; i < max_mem_index; ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (auto & i : reusable_memory_) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/tss_ptr.hpp:50:3: warning: operator=() should return 'tss_ptr&' [misc-unconventional-assign-operator] + void operator=(T* value) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/wrapped_handler.hpp:66:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + wrapped_handler(wrapped_handler&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/detail/wrapped_handler.hpp:181:3: warning: move constructors should be marked noexcept [performance-noexcept-move-constructor] + rewrapped_handler(rewrapped_handler&& other) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:257:3: warning: initialization of 'system_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + system_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:226:36: note: possibly throwing function declared here +inline const asio::error_category& get_system_category() + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:260:3: warning: initialization of 'netdb_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + netdb_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:234:29: note: possibly throwing function declared here +const asio::error_category& get_netdb_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:263:3: warning: initialization of 'addrinfo_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + addrinfo_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:237:29: note: possibly throwing function declared here +const asio::error_category& get_addrinfo_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:266:3: warning: initialization of 'misc_category' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] + misc_category ASIO_UNUSED_VARIABLE + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/error.hpp:254:29: note: possibly throwing function declared here +const asio::error_category& get_misc_category(); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:208:19: warning: redundant 'use_service' declaration [readability-redundant-declaration] + friend Service& use_service(execution_context& e); + ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:33:38: note: previously declared here +template Service& use_service(execution_context&); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:225:19: warning: redundant 'use_service' declaration [readability-redundant-declaration] + friend Service& use_service(io_context& ioc); + ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:34:38: note: previously declared here +template Service& use_service(io_context&); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:285:15: warning: redundant 'add_service' declaration [readability-redundant-declaration] + friend void add_service(execution_context& e, Service* svc); + ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:35:34: note: previously declared here +template void add_service(execution_context&, Service*); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:298:15: warning: redundant 'has_service' declaration [readability-redundant-declaration] + friend bool has_service(execution_context& e); + ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:36:34: note: previously declared here +template bool has_service(execution_context&); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:400:56: warning: initialization of 'id' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp] +service_id execution_context_service_base::id; + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:379:7: note: possibly throwing constructor declared here +class service_id + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/executor.hpp:38:33: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual const char* what() const + ~~~~~~~~~~~~~~ ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/handler_continuation_hook.hpp:45:13: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline bool asio_handler_is_continuation(...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/handler_invoke_hook.hpp:66:13: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline void asio_handler_invoke(Function& function, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/handler_invoke_hook.hpp:73:13: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +inline void asio_handler_invoke(const Function& function, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error.ipp:34:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const char* name() const ASIO_ERROR_CATEGORY_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error.ipp:39:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + std::string message(int value) const + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error.ipp:66:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const char* name() const ASIO_ERROR_CATEGORY_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error.ipp:71:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + std::string message(int value) const + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error.ipp:96:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const char* name() const ASIO_ERROR_CATEGORY_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error.ipp:101:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + std::string message(int value) const + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error_code.ipp:40:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const char* name() const ASIO_ERROR_CATEGORY_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/error_code.ipp:45:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + std::string message(int value) const + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:149:14: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + impl_base* clone() const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:155:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void destroy() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:166:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void on_work_started() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:171:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void on_work_finished() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:176:22: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + execution_context& context() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:181:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void dispatch(ASIO_MOVE_ARG(function) f) + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:186:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void post(ASIO_MOVE_ARG(function) f) + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:191:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void defer(ASIO_MOVE_ARG(function) f) + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:196:23: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + type_id_result_type target_type() const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:201:9: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void* target() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:206:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const void* target() const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:211:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + bool equals(const impl_base* e) const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:266:14: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + impl_base* clone() const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:271:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void destroy() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:275:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void on_work_started() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:280:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void on_work_finished() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:285:22: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + execution_context& context() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:290:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void dispatch(ASIO_MOVE_ARG(function) f) + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:295:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void post(ASIO_MOVE_ARG(function) f) + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:300:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void defer(ASIO_MOVE_ARG(function) f) + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:305:23: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + type_id_result_type target_type() const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:310:9: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + void* target() ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:315:15: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + const void* target() const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/executor.hpp:320:8: warning: annotate this function with 'override' or (rarely) 'final' [modernize-use-override] + bool equals(const impl_base* e) const ASIO_NOEXCEPT + ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/handler_alloc_hook.ipp:27:7: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +void* asio_handler_allocate(std::size_t size, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/impl/handler_alloc_hook.ipp:37:6: warning: do not define a C-style variadic function; consider using a function parameter pack or currying instead [cert-dcl50-cpp] +void asio_handler_deallocate(void* pointer, std::size_t size, ...) + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:608:19: warning: redundant 'use_service' declaration [readability-redundant-declaration] + friend Service& use_service(io_context& ioc); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/execution_context.hpp:225:19: note: previously declared here + friend Service& use_service(io_context& ioc); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:795:26: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual void shutdown(); + ~~~~~~~~~~~~~^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:809:26: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual void notify_fork( + ~~~~~~~~~~~~~^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/io_context.hpp:831:21: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + ASIO_DECL virtual ~service(); + ~~~~~~~~^ ~ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4_iterator.hpp:56:26: warning: pass by value and use std::move [modernize-pass-by-value] + basic_address_iterator(const address_v4& addr) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~~~ + address_v4 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4_iterator.hpp:114:3: warning: overloaded 'operator++' returns a non-constant object instead of a constant object type [cert-dcl21-cpp] + basic_address_iterator operator++(int) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~~~~~~~~ + const +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4_iterator.hpp:129:3: warning: overloaded 'operator--' returns a non-constant object instead of a constant object type [cert-dcl21-cpp] + basic_address_iterator operator--(int) + ^~~~~~~~~~~~~~~~~~~~~~ + const +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4_range.hpp:48:32: warning: pass by value and use std::move [modernize-pass-by-value] + explicit basic_address_range(const iterator& first, + ^~~~~~~~~~~~~~~ + iterator +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4_range.hpp:49:7: warning: pass by value and use std::move [modernize-pass-by-value] + const iterator& last) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~ + iterator +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v6_iterator.hpp:57:26: warning: pass by value and use std::move [modernize-pass-by-value] + basic_address_iterator(const address_v6& addr) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~~~ + address_v6 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v6_iterator.hpp:125:3: warning: overloaded 'operator++' returns a non-constant object instead of a constant object type [cert-dcl21-cpp] + basic_address_iterator operator++(int) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~~~~~~~~ + const +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v6_iterator.hpp:150:3: warning: overloaded 'operator--' returns a non-constant object instead of a constant object type [cert-dcl21-cpp] + basic_address_iterator operator--(int) + ^~~~~~~~~~~~~~~~~~~~~~ + const +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v6_range.hpp:49:32: warning: pass by value and use std::move [modernize-pass-by-value] + explicit basic_address_range(const iterator& first, + ^~~~~~~~~~~~~~~ + iterator +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v6_range.hpp:50:7: warning: pass by value and use std::move [modernize-pass-by-value] + const iterator& last) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~ + iterator +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/bad_address_cast.hpp:39:11: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual ~bad_address_cast() ASIO_NOEXCEPT_OR_NOTHROW {} + ~~~~~~~~^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/bad_address_cast.hpp:42:23: warning: prefer using 'override' or (rarely) 'final' instead of 'virtual' [modernize-use-override] + virtual const char* what() const ASIO_NOEXCEPT_OR_NOTHROW + ~~~~~~~~~~~~~~ ^ + override +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:34:5: warning: initializer for member 'ipv4_address_' is redundant [readability-redundant-member-init] + ipv4_address_(), + ^~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:35:5: warning: initializer for member 'ipv6_address_' is redundant [readability-redundant-member-init] + ipv6_address_() + ^~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:40:5: warning: pass by value and use std::move [modernize-pass-by-value] + const asio::ip::address_v4& ipv4_address) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + asio::ip::address_v4 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:43:5: warning: initializer for member 'ipv6_address_' is redundant [readability-redundant-member-init] + ipv6_address_() + ^~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:48:5: warning: pass by value and use std::move [modernize-pass-by-value] + const asio::ip::address_v6& ipv6_address) ASIO_NOEXCEPT + ^~~~~~~~~~~~~~~~~~~~~~~~~~~ + asio::ip::address_v6 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:50:5: warning: initializer for member 'ipv4_address_' is redundant [readability-redundant-member-init] + ipv4_address_(), + ^~~~~~~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/address.ipp:65:5: warning: move constructor initializes class member by calling a copy constructor [cert-oop11-cpp] + ipv4_address_(other.ipv4_address_), + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4.hpp:75:3: note: copy constructor being called + address_v4(const address_v4& other) ASIO_NOEXCEPT + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/address_v4.hpp:82:3: note: candidate move constructor here + address_v4(address_v4&& other) ASIO_NOEXCEPT + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.hpp:42:5: warning: use range-based for loop instead [modernize-loop-convert] + for (std::string::iterator i = s.begin(); i != s.end(); ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (char & i : s) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.ipp:34:24: warning: pass by value and use std::move [modernize-pass-by-value] +network_v4::network_v4(const address_v4& addr, unsigned short prefix_len) + ^~~~~~~~~~~~~~~~~ + address_v4 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.ipp:45:24: warning: pass by value and use std::move [modernize-pass-by-value] +network_v4::network_v4(const address_v4& addr, const address_v4& mask) + ^~~~~~~~~~~~~~~~~ + address_v4 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.ipp:51:3: warning: use range-based for loop instead [modernize-loop-convert] + for (std::size_t i = 0; i < mask_bytes.size(); ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (unsigned char mask_byte : mask_bytes) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.ipp:161:50: warning: 'find_first_of' called with a string literal consisting of a single character; consider using the more effective overload accepting a character [performance-faster-string-find] + std::string::size_type pos = str.find_first_of("/"); + ^~~~ + '/' +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.ipp:186:26: warning: 'atoi' used to convert a string to an integer value, but function will not report conversion errors; consider using 'strtol' instead [cert-err34-c] + const int prefix_len = std::atoi(str.substr(pos + 1).c_str()); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v6.hpp:41:5: warning: use range-based for loop instead [modernize-loop-convert] + for (std::string::iterator i = s.begin(); i != s.end(); ++i) + ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + (char & i : s) +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v6.ipp:34:24: warning: pass by value and use std::move [modernize-pass-by-value] +network_v6::network_v6(const address_v6& addr, unsigned short prefix_len) + ^~~~~~~~~~~~~~~~~ + address_v6 +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v6.ipp:130:50: warning: 'find_first_of' called with a string literal consisting of a single character; consider using the more effective overload accepting a character [performance-faster-string-find] + std::string::size_type pos = str.find_first_of("/"); + ^~~~ + '/' +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v6.ipp:155:26: warning: 'atoi' used to convert a string to an integer value, but function will not report conversion errors; consider using 'strtol' instead [cert-err34-c] + const int prefix_len = std::atoi(str.substr(pos + 1).c_str()); + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/network_v4.hpp:44:7: warning: initializer for member 'address_' is redundant [readability-redundant-member-init] + : address_(), + ^~~~~~~~~~~ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/network_v4.hpp:246:35: warning: function 'asio::ip::operator<<' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name] +std::basic_ostream& operator<<( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v4.hpp:29:35: note: the definition seen here +std::basic_ostream& operator<<( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/network_v4.hpp:246:35: note: differing parameters are named here: ('net'), in definition: ('addr') +std::basic_ostream& operator<<( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/network_v6.hpp:220:35: warning: function 'asio::ip::operator<<' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name] +std::basic_ostream& operator<<( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/impl/network_v6.hpp:28:35: note: the definition seen here +std::basic_ostream& operator<<( + ^ +/Users/clausklein/Workspace/cpp/asio/asio/include/asio/ip/network_v6.hpp:220:35: note: differing parameters are named here: ('net'), in definition: ('addr') +std::basic_ostream& operator<<( + ^ +[3/3] Linking CXX static library lib/libasio.a diff --git a/conan/README.rst b/conan/README.rst new file mode 100644 index 0000000000..75c486487d --- /dev/null +++ b/conan/README.rst @@ -0,0 +1,84 @@ +======================================================= +This example is created to test the conan asio package: +======================================================= + +This conan package of asio is a header only standalone distribution build with cmake. + + $cp ../asio/src/examples/cpp14/executors/priority_scheduler.cpp test_package/example.cpp + + +How to use: +=========== + +see too https://bincrafters.github.io/2018/02/27/Updated-Conan-Package-Flow-1.1/ + +:: + + $conan create . bincrafters/testing + + ... + + asio/1.12.1@bincrafters/testing: Package '5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' built + asio/1.12.1@bincrafters/testing: Build folder /Users/clausklein/.conan/data/asio/1.12.1/bincrafters/testing/build/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 + asio/1.12.1@bincrafters/testing: Generated conaninfo.txt + asio/1.12.1@bincrafters/testing: Generated conanbuildinfo.txt + asio/1.12.1@bincrafters/testing: Generating the package + asio/1.12.1@bincrafters/testing: Package folder /Users/clausklein/.conan/data/asio/1.12.1/bincrafters/testing/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 + asio/1.12.1@bincrafters/testing: Calling package() + asio/1.12.1@bincrafters/testing package(): WARN: No files copied! + asio/1.12.1@bincrafters/testing package(): WARN: No files copied! + asio/1.12.1@bincrafters/testing: Package '5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' created + asio/1.12.1@bincrafters/testing (test package): Generator cmake created conanbuildinfo.cmake + asio/1.12.1@bincrafters/testing (test package): Generator txt created conanbuildinfo.txt + asio/1.12.1@bincrafters/testing (test package): Generated conaninfo.txt + asio/1.12.1@bincrafters/testing (test package): Running build() + + ----Running------ + > cd '/var/folders/wb/ckvxxgls5db7qyhqq4y5_l1c0000gq/T/conansQqfoiE' && cmake -G "Ninja" -DCMAKE_BUILD_TYPE="Release" -DCONAN_EXPORTED="1" -DCONAN_COMPILER="apple-clang" -DCONAN_COMPILER_VERSION="8.0" -DCONAN_CXX_FLAGS="-m64" -DCONAN_SHARED_LINKER_FLAGS="-m64" -DCONAN_C_FLAGS="-m64" -DCONAN_LIBCXX="libc++" -Wno-dev '/Users/clausklein/Workspace/cpp/asio/conan/test_package' + ----------------- + -- The CXX compiler identification is AppleClang 8.0.0.8000042 + -- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++ + -- Check for working CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++ -- works + -- Detecting CXX compiler ABI info + -- Detecting CXX compiler ABI info - done + -- Detecting CXX compile features + -- Detecting CXX compile features - done + -- Conan: called by CMake conan helper + -- Conan: Using cmake targets configuration + -- Conan: Adjusting default RPATHs Conan policies + -- Conan: Adjusting language standard + -- Conan: C++ stdlib: libc++ + -- Configuring done + -- Generating done + -- Build files have been written to: /var/folders/wb/ckvxxgls5db7qyhqq4y5_l1c0000gq/T/conansQqfoiE + + ----Running------ + > cmake --build '/var/folders/wb/ckvxxgls5db7qyhqq4y5_l1c0000gq/T/conansQqfoiE' + ----------------- + [1/2] Building CXX object CMakeFiles/example.dir/example.cpp.o + [2/2] Linking CXX executable bin/example + + ----Running------ + > cmake --build '/var/folders/wb/ckvxxgls5db7qyhqq4y5_l1c0000gq/T/conansQqfoiE' '--target' 'test' + ----------------- + [0/1] Running tests... + Test project /var/folders/wb/ckvxxgls5db7qyhqq4y5_l1c0000gq/T/conansQqfoiE + Start 1: example + 1/1 Test #1: example .......................... Passed 0.01 sec + + 100% tests passed, 0 tests failed out of 1 + + Total Test time (real) = 0.02 sec + asio/1.12.1@bincrafters/testing (test package): Running test() + + ----Running------ + > ./example + ----------------- + 3 + 33 + 333 + 2 + 22 + 11 + 1 + bash-4.4$ diff --git a/conan/conanfile.py b/conan/conanfile.py new file mode 100644 index 0000000000..2a9a3392cd --- /dev/null +++ b/conan/conanfile.py @@ -0,0 +1,70 @@ +from conans import ConanFile, CMake, tools + +# from coanan exampe for "How to package header-only libraries" + + +class AsioConan(ConanFile): + name = "asio" + version = "1.12.1" + license = "Boost Software License - Version 1.0" + url = "https://github.com/chriskohlhoff/asio/issues" + description = "Asio C++ Library" + settings = "os", "compiler", "build_type", "arch" + options = { + "shared": [True, False], + "header_only": [True, False], + "force_openssl": [True, False], + "cxx_14": [True, False] + } + default_options = ''' +shared=False +header_only=True +force_openssl=True +cxx_14=True +''' + generators = "cmake" + exports_sources = "../asio/*" + no_copy_source = True + + def requirements(self): + if not self.options.header_only: + if self.options.force_openssl: + self.requires.add("OpenSSL/1.0.2n@conan/stable", private=False) + + def build(self): + cmake = CMake(self) + if self.options.header_only: + definitions = { + "ASIO_SEPARATE_COMPILATION": "OFF" + } + cmake.configure(defs=definitions, source_folder=".") + else: + cmake.configure(source_folder=".") + cmake.build() + if not tools.cross_building(self.settings): + if tools.get_env("CONAN_RUN_TESTS", True): + cmake.test() + cmake.install() + + def package(self): + pass + # NOTE: done by cmake.install() + # self.copy("*.hpp", dst="include", src="include") + # self.copy("*.ipp", dst="include", src="include") + # self.copy("*.lib", dst="lib", keep_path=False) + # self.copy("*.dll", dst="bin", keep_path=False) + # self.copy("*.dylib*", dst="lib", keep_path=False) + # self.copy("*.so", dst="lib", keep_path=False) + # self.copy("*.a", dst="lib", keep_path=False) + + def package_id(self): + if self.options.header_only: + self.info.header_only() + + # NOTE: If header only is used, there is no need for a custom + # package_info() method! + def package_info(self): + self.cpp_info.defines.append("ASIO_STANDALONE") + self.cpp_info.defines.append("ASIO_NO_DEPRECATED") + if not self.options.header_only: + self.cpp_info.libs = ["asio"] diff --git a/conan/test_package/CMakeLists.txt b/conan/test_package/CMakeLists.txt new file mode 100644 index 0000000000..8b285bc307 --- /dev/null +++ b/conan/test_package/CMakeLists.txt @@ -0,0 +1,18 @@ +project(PackageTest CXX) +cmake_minimum_required(VERSION 3.13) +set(CMAKE_CXX_STANDARD 17) + +include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) +conan_basic_setup(TARGETS) + +add_executable(example example.cpp) +conan_target_link_libraries(example) +# or explicit: +# target_link_libraries(example ${CONAN_LIBS}) + +# CTest is a testing tool that can be used to test your project. +enable_testing() +add_test(NAME example + WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/bin + COMMAND example +) diff --git a/conan/test_package/conanfile.py b/conan/test_package/conanfile.py new file mode 100644 index 0000000000..1cbb038528 --- /dev/null +++ b/conan/test_package/conanfile.py @@ -0,0 +1,24 @@ +from conans import ConanFile, CMake, tools +import os + +class AsioTestConan(ConanFile): + settings = "os", "compiler", "build_type", "arch" + generators = "cmake" + + def build(self): + cmake = CMake(self) + # Current dir is "test_package/build/" and CMakeLists.txt is in "test_package" + cmake.configure() + cmake.build() + if tools.get_env("CONAN_RUN_TESTS", True): + cmake.test() + + def imports(self): + self.copy("*.dll", dst="bin", src="bin") + self.copy("*.dylib*", dst="bin", src="lib") + self.copy('*.so*', dst='bin', src='lib') + + def test(self): + if not tools.cross_building(self.settings): + os.chdir("bin") + self.run(".%sexample" % os.sep) diff --git a/conan/test_package/example.cpp b/conan/test_package/example.cpp new file mode 100644 index 0000000000..3b28af1eec --- /dev/null +++ b/conan/test_package/example.cpp @@ -0,0 +1,167 @@ +#include +#include +#include +#include +#include +#include + +using asio::dispatch; +using asio::execution_context; + +class priority_scheduler : public execution_context +{ +public: + // A class that satisfies the Executor requirements. + class executor_type + { + public: + executor_type(priority_scheduler& ctx, int pri) noexcept + : context_(ctx), priority_(pri) + { + } + + priority_scheduler& context() const noexcept + { + return context_; + } + + void on_work_started() const noexcept + { + // This executor doesn't count work. Instead, the scheduler simply runs + // until explicitly stopped. + } + + void on_work_finished() const noexcept + { + // This executor doesn't count work. Instead, the scheduler simply runs + // until explicitly stopped. + } + + template + void dispatch(Func&& f, const Alloc& a) const + { + post(std::forward(f), a); + } + + template + void post(Func f, const Alloc& a) const + { + auto p(std::allocate_shared>( + typename std::allocator_traits< + Alloc>::template rebind_alloc(a), + priority_, std::move(f))); + std::lock_guard lock(context_.mutex_); + context_.queue_.push(p); + context_.condition_.notify_one(); + } + + template + void defer(Func&& f, const Alloc& a) const + { + post(std::forward(f), a); + } + + friend bool operator==(const executor_type& a, + const executor_type& b) noexcept + { + return &a.context_ == &b.context_; + } + + friend bool operator!=(const executor_type& a, + const executor_type& b) noexcept + { + return &a.context_ != &b.context_; + } + + private: + priority_scheduler& context_; + int priority_; + }; + + executor_type get_executor(int pri = 0) noexcept + { + return executor_type(*const_cast(this), pri); + } + + void run() + { + std::unique_lock lock(mutex_); + for (;;) + { + condition_.wait(lock, [&]{ return stopped_ || !queue_.empty(); }); + if (stopped_) + return; + auto p(queue_.top()); + queue_.pop(); + lock.unlock(); + p->execute_(p); + lock.lock(); + } + } + + void stop() + { + std::lock_guard lock(mutex_); + stopped_ = true; + condition_.notify_all(); + } + +private: + struct item_base + { + int priority_; + void (*execute_)(std::shared_ptr&); + }; + + template + struct item : item_base + { + item(int pri, Func f) : function_(std::move(f)) + { + priority_ = pri; + execute_ = [](std::shared_ptr& p) + { + Func tmp(std::move(static_cast(p.get())->function_)); + p.reset(); + tmp(); + }; + } + + Func function_; + }; + + struct item_comp + { + bool operator()( + const std::shared_ptr& a, + const std::shared_ptr& b) + { + return a->priority_ < b->priority_; + } + }; + + std::mutex mutex_; + std::condition_variable condition_; + std::priority_queue< + std::shared_ptr, + std::vector>, + item_comp> queue_; + bool stopped_ = false; +}; + +int main() +{ + priority_scheduler sched; + auto low = sched.get_executor(0); + auto med = sched.get_executor(1); + auto high = sched.get_executor(2); + dispatch(low, []{ std::cout << "1\n"; }); + dispatch(low, []{ std::cout << "11\n"; }); + dispatch(med, []{ std::cout << "2\n"; }); + dispatch(med, []{ std::cout << "22\n"; }); + dispatch(high, []{ std::cout << "3\n"; }); + dispatch(high, []{ std::cout << "33\n"; }); + dispatch(high, []{ std::cout << "333\n"; }); + dispatch(sched.get_executor(-1), [&]{ sched.stop(); }); + sched.run(); +}