CMakeLists.txt

cmake_minimum_required(VERSION 3.25...4.2)

project(RRCP-client VERSION 0.2.0.2 LANGUAGES CXX)

# ---- add dependencies ----

find_package(Threads)

set(BOOST_INCLUDE_LIBRARIES algorithm asio beast signals2)

# see too: https://cmake.org/cmake/help/latest/module/FindBoost.html
set(Boost_DEBUG ON)
find_package(Boost CONFIG) # XXX COMPONENTS ${BOOST_INCLUDE_LIBRARIES} HINTS $ENV{HOME}/.local)
if(Boost_FOUND)
    set(BOOST_LIBRARIES Boost::headers)
else()
    include(cmake/CPM.cmake)

    set(BOOST_LIBRARIES ${BOOST_INCLUDE_LIBRARIES})
    list(TRANSFORM BOOST_LIBRARIES PREPEND Boost::)

    if(NOT TARGET Boost::headers)
        #
        # build only the requested Boost components
        #
        cpmaddpackage(
          NAME boost-cmake
          VERSION 1.87.0.6
          GIT_TAG v1.87.0-rc6
          GITHUB_REPOSITORY ClausKlein/boost-cmake
          EXCLUDE_FROM_ALL NO
          SYSTEM YES
        )
    endif()
endif()

include(FetchContent)

FetchContent_Declare(
    fmt
    GIT_TAG 12.0.0
    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
    EXCLUDE_FROM_ALL
    SYSTEM
    FIND_PACKAGE_ARGS 12.0.0 NAMES fmt HINTS $ENV{HOME}/.local
)

FetchContent_MakeAvailable(fmt)

# ---- default settings ----

if(DEFINED ENV{CI})
    message(STATUS "Running inside a CI environment")
else()
    message(STATUS "Running locally")

    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
        if(APPLE)
            execute_process(
                OUTPUT_VARIABLE LLVM_PREFIX
                COMMAND brew --prefix llvm
                COMMAND_ECHO STDOUT
            )
            string(STRIP ${LLVM_PREFIX} LLVM_PREFIX)
        elseif(LINUX)
            set(LLVM_PREFIX $ENV{LLVM_ROOT})
        endif()

        add_compile_options(-fexperimental-library)
        add_link_options(-L${LLVM_PREFIX}/lib/c++ -lc++experimental)
    endif()
endif()

set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# ---- code coverage ----

option(BUILD_TESTING "Build ctest" ${PROJECT_IS_TOP_LEVEL})
option(BUILD_EXAMPLES "Compile examples too" NO)
option(
    ENABLE_TEST_COVERAGE
    "Compile with test-coverage flags"
    ${PROJECT_IS_TOP_LEVEL}
)
if(UNIX AND ENABLE_TEST_COVERAGE AND CMAKE_BUILD_TYPE STREQUAL Debug)
    message(WARNING "ENABLE_TEST_COVERAGE is set!")
    add_compile_options(-O0 -g -fprofile-arcs -ftest-coverage)
    add_link_options(-fprofile-arcs -ftest-coverage)
    # FIXME: add_compile_definitions(TARGET_CODE_COVERAGE)
endif()

# ---- ctest ----

enable_testing()

function(do_test target arg result)
    if(BUILD_TESTING)
        add_test(NAME ${target}${arg} COMMAND ${target} ${arg})
        set_tests_properties(
            ${target}${arg}
            PROPERTIES PASS_REGULAR_EXPRESSION ${result}
        )
    endif()
endfunction()

# ---- echo server needed for tests ----

add_executable(async_tcp_echo_server examples/async_tcp_echo_server.cpp)
target_link_libraries(
    async_tcp_echo_server
    PUBLIC Threads::Threads ${BOOST_LIBRARIES}
)
do_test(async_tcp_echo_server "" port)

# ---- rrcp class sources and helpers as a library ----

find_program(
    PYTHON_EXECUTABLE
    NAMES python3 python
    REQUIRED
    HINTS $ENV{VIRTUAL_ENV}/bin
)

add_library(rrcp_helper STATIC)
target_sources(
    rrcp_helper
    PRIVATE rrcp_helper.cpp
    PUBLIC
        FILE_SET
            HEADERS #
            FILES
                async_rrcp_client.hpp
                async_rrcp_client_threadsafe.hpp
                rrcp_helper.hpp
)
target_link_libraries(
    rrcp_helper
    PUBLIC Threads::Threads ${BOOST_LIBRARIES} fmt::fmt-header-only
)

# ---- simple rrcp client class usage examples ----

if(BUILD_EXAMPLES AND NOT ENABLE_TEST_COVERAGE)
    add_executable(async_tcp_echo_client examples/async_tcp_echo_client.cpp)
    target_link_libraries(async_tcp_echo_client PRIVATE rrcp_helper)
    do_test(async_tcp_echo_client --help Usage)
    add_test(
        NAME async_tcp_echo_client-test
        COMMAND
            ${PYTHON_EXECUTABLE} #
            ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py #
            --client $<TARGET_FILE:async_tcp_echo_client> #
            --server $<TARGET_FILE:async_tcp_echo_server>
    )
    add_test(
        NAME async_tcp_echo_client-test-no_server
        COMMAND
            ${PYTHON_EXECUTABLE} #
            ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py #
            --client $<TARGET_FILE:async_tcp_echo_client> #
            --timeout 9
    )

    add_executable(
        blocking_tcp_echo_client
        examples/blocking_tcp_echo_client.cpp
    )
    target_link_libraries(blocking_tcp_echo_client PRIVATE rrcp_helper)
    do_test(blocking_tcp_echo_client --help Usage)

    add_executable(rrcp_client rrcp_client.cpp rrcp_message.hpp)
    target_link_libraries(rrcp_client PRIVATE rrcp_helper)
    do_test(rrcp_client --help Usage)

    # TODO(CK): mv to examples too!
    add_executable(timer timer.cpp)
    target_link_libraries(
        timer
        PUBLIC Threads::Threads ${BOOST_LIBRARIES} fmt::fmt-header-only
    )
    add_test(NAME timer COMMAND timer)
endif()

# ---- theadsafe rrcp client class usage examples main  ----

add_executable(rrcp_async_tcp_client_threadsafe rrcp_async_tcp_client.cpp)
target_link_libraries(rrcp_async_tcp_client_threadsafe PRIVATE rrcp_helper)
do_test(rrcp_async_tcp_client_threadsafe --help Usage)
add_test(
    NAME rrcp_async_tcp_client_threadsafe-test-no_server
    COMMAND
        ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py #
        --client $<TARGET_FILE:rrcp_async_tcp_client_threadsafe> #
        --timeout 9
)
add_test(
    NAME rrcp_async_tcp_client_threadsafe-test
    COMMAND
        ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py #
        --client $<TARGET_FILE:rrcp_async_tcp_client_threadsafe> #
        --server $<TARGET_FILE:async_tcp_echo_server> #
        --input ${CMAKE_CURRENT_SOURCE_DIR}/rrcp.txt #
)

add_executable(rrcp_async_tcp_client rrcp_async_tcp_client.cpp)
target_link_libraries(rrcp_async_tcp_client PRIVATE rrcp_helper)
target_compile_definitions(rrcp_async_tcp_client PRIVATE USE_SIMPLE_RRCP_CLIENT)
do_test(rrcp_async_tcp_client --help Usage)
add_test(
    NAME rrcp_async_tcp_client-test-no_server
    COMMAND
        ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py #
        --client $<TARGET_FILE:rrcp_async_tcp_client> #
        --timeout 9
)
add_test(
    NAME rrcp_async_tcp_client-test
    COMMAND
        ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/run_test.py #
        --client $<TARGET_FILE:rrcp_async_tcp_client> #
        --server $<TARGET_FILE:async_tcp_echo_server> #
        --input ${CMAKE_CURRENT_SOURCE_DIR}/rrcp.txt #
)

if(BUILD_TESTING)
    add_subdirectory(tests)
endif()

if(APPLE AND BUILD_EXAMPLES)
    add_subdirectory(examples)
endif()