Commit 97cf0d51 authored by Dominik Charousset's avatar Dominik Charousset

Fix exporting and installing of incubator libs

parent 8b28db8d
cmake_minimum_required(VERSION 3.13.5 FATAL_ERROR)
cmake_minimum_required(VERSION 3.13.5...3.18 FATAL_ERROR)
project(CAF_INC CXX)
set(CMAKE_CXX_STANDARD 17)
# -- includes ------------------------------------------------------------------
include(CMakePackageConfigHelpers) # For creating .cmake files
include(CheckCXXSourceCompiles) # Check wether compiler works
include(FetchContent) # For bundling CAF with the incubator
include(GNUInstallDirs) # Sets default install paths
include(GenerateExportHeader) # Auto-generates dllexport macros
include(CMakePackageConfigHelpers)
include(CheckCXXSourceCompiles)
include(FetchContent)
include(GNUInstallDirs)
include(GenerateExportHeader)
# -- override CMake defaults for internal cache entries ------------------------
set(CMAKE_EXPORT_COMPILE_COMMANDS ON
CACHE INTERNAL "Write JSON compile commands database")
# -- general options -----------------------------------------------------------
option(BUILD_SHARED_LIBS "Build shared library targets" ON)
......@@ -68,10 +67,10 @@ endif()
# -- set the library version for shared library targets ------------------------
if(CMAKE_HOST_SYSTEM_NAME MATCHES "OpenBSD")
set(CAF_LIB_VERSION "${CAF_VERSION_MAJOR}.${CAF_VERSION_MINOR}"
set(CAF_INC_LIB_VERSION "${CAF_VERSION_MAJOR}.${CAF_VERSION_MINOR}"
CACHE INTERNAL "The version string used for shared library objects")
else()
set(CAF_LIB_VERSION "${CAF_VERSION}"
set(CAF_INC_LIB_VERSION "${CAF_VERSION}"
CACHE INTERNAL "The version string used for shared library objects")
endif()
......@@ -81,40 +80,7 @@ if(MSVC AND CAF_INC_SANITIZERS)
message(FATAL_ERROR "Sanitizer builds are currently not supported on MSVC")
endif()
# -- compiler setup ------------------------------------------------------------
function(caf_incubator_set_default_properties)
foreach(target ${ARGN})
if(MSVC)
# Disable 4275 and 4251 (warnings regarding C++ classes at ABI boundaries).
target_compile_options(${target} PRIVATE /wd4275 /wd4251)
elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang"
OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
# Flags for both compilers.
target_compile_options(${target} PRIVATE
-ftemplate-depth=512 -ftemplate-backtrace-limit=0
-Wall -Wextra -pedantic)
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
# Flags for Clang only.
target_compile_options(${target} PRIVATE -Wdocumentation)
else()
# Flags for GCC only.
target_compile_options(${target} PRIVATE
-Wno-missing-field-initializers)
endif()
endif()
if(CAF_INC_SANITIZERS)
target_compile_options(${target} PRIVATE
-fsanitize=${CAF_INC_SANITIZERS}
-fno-omit-frame-pointer)
target_link_libraries(${target} PRIVATE
-fsanitize=${CAF_INC_SANITIZERS}
-fno-omit-frame-pointer)
endif()
endforeach()
endfunction()
# -- unit testing setup / caf_add_test_suites function ------------------------
# -- unit testing setup --------------------------------------------------------
if(CAF_INC_ENABLE_TESTING)
enable_testing()
......@@ -129,16 +95,6 @@ if(CAF_INC_ENABLE_TESTING)
endfunction()
endif()
# -- set default visibility to hidden when building shared libs ----------------
if(BUILD_SHARED_LIBS)
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_VISIBILITY_INLINES_HIDDEN yes)
if(POLICY CMP0063)
cmake_policy(SET CMP0063 NEW)
endif()
endif()
# -- utility targets -----------------------------------------------------------
if(CAF_INC_ENABLE_UTILITY_TARGETS)
......@@ -181,6 +137,143 @@ else()
endfunction()
endif()
# -- utility functions ---------------------------------------------------------
function(caf_incubator_export_and_install_lib component)
add_library(CAF::${component} ALIAS libcaf_${component})
target_include_directories(libcaf_${component} INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
$<INSTALL_INTERFACE:include>)
set_target_properties(libcaf_${component} PROPERTIES
EXPORT_NAME ${component}
SOVERSION ${CAF_VERSION}
VERSION ${CAF_INC_LIB_VERSION}
OUTPUT_NAME caf_${component})
install(TARGETS libcaf_${component}
EXPORT CAFIncubatorTargets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT ${component}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT ${component}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT ${component})
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/caf"
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
COMPONENT ${component}
FILES_MATCHING PATTERN "*.hpp")
get_target_property(lib_type libcaf_${component} TYPE)
if(NOT lib_type STREQUAL "INTERFACE_LIBRARY")
string(TOUPPER "CAF_${component}_EXPORT" export_macro_name)
generate_export_header(
libcaf_${component}
EXPORT_MACRO_NAME ${export_macro_name}
EXPORT_FILE_NAME "caf/detail/${component}_export.hpp")
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/caf/detail/${component}_export.hpp"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/caf/detail/")
endif()
endfunction()
# -- convenience function for automating our component setup -------------------
# Usage:
# caf_incubator_add_component(
# foo
# DEPENDENCIES
# INTERFACE
# ...
# PUBLIC
# ...
# PRIVATE
# ...
# HEADERS
# ...
# SOURCES
# ...
# TEST_SOURCES
# ...
# TEST_SUITES
# ...
# )
function(caf_incubator_add_component name)
set(varargs DEPENDENCIES HEADERS SOURCES TEST_SOURCES TEST_SUITES
ENUM_CONSISTENCY_CHECKS)
cmake_parse_arguments(CAF_INC_ADD_COMPONENT "" "" "${varargs}" ${ARGN})
if(NOT CAF_INC_ADD_COMPONENT_HEADERS)
message(FATAL_ERROR "Cannot add CAF component without at least one header.")
endif()
foreach(param DEPENDENCIES HEADERS)
if(NOT CAF_INC_ADD_COMPONENT_${param})
message(FATAL_ERROR "caf_add_component(): missing parameter ${param}")
endif()
endforeach()
set(pub_lib_target "libcaf_${name}")
set(obj_lib_target "libcaf_${name}_obj")
set(tst_bin_target "caf-${name}-test")
if(NOT CAF_INC_ADD_COMPONENT_SOURCES)
# header-only library
add_library(${pub_lib_target} INTERFACE)
if(CAF_INC_ENABLE_TESTING AND CAF_INC_ADD_COMPONENT_TEST_SOURCES)
set(targets ${tst_bin_target})
add_executable(${tst_bin_target}
${CAF_INC_ADD_COMPONENT_TEST_SOURCES})
target_link_libraries(${tst_bin_target} PRIVATE CAF::test
${CAF_INC_ADD_COMPONENT_DEPENDENCIES})
target_include_directories(${tst_bin_target} PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/test")
if(CAF_INC_ADD_COMPONENT_TEST_SUITES)
caf_incubator_add_test_suites(${tst_bin_target}
${CAF_INC_ADD_COMPONENT_TEST_SUITES})
endif()
endif()
elseif(CAF_INC_ENABLE_TESTING AND CAF_INC_ADD_COMPONENT_TEST_SOURCES)
set(targets ${pub_lib_target} ${obj_lib_target} ${tst_bin_target})
add_library(${obj_lib_target} OBJECT
${CAF_INC_ADD_COMPONENT_HEADERS}
${CAF_INC_ADD_COMPONENT_SOURCES})
set_property(TARGET ${obj_lib_target} PROPERTY POSITION_INDEPENDENT_CODE ON)
target_link_libraries(${obj_lib_target}
${CAF_INC_ADD_COMPONENT_DEPENDENCIES})
add_library(${pub_lib_target}
"${PROJECT_SOURCE_DIR}/cmake/dummy.cpp"
$<TARGET_OBJECTS:${obj_lib_target}>)
add_executable(${tst_bin_target}
${CAF_INC_ADD_COMPONENT_TEST_SOURCES}
$<TARGET_OBJECTS:${obj_lib_target}>)
target_link_libraries(${tst_bin_target} PRIVATE CAF::test
${CAF_INC_ADD_COMPONENT_DEPENDENCIES})
target_include_directories(${tst_bin_target} PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/test")
if(CAF_INC_ADD_COMPONENT_TEST_SUITES)
caf_incubator_add_test_suites(${tst_bin_target}
${CAF_INC_ADD_COMPONENT_TEST_SUITES})
endif()
else()
set(targets ${pub_lib_target})
add_library(${pub_lib_target}
${CAF_INC_ADD_COMPONENT_HEADERS})
set_property(TARGET ${pub_lib_target} PROPERTY POSITION_INDEPENDENT_CODE ON)
endif()
target_link_libraries(${pub_lib_target} ${CAF_INC_ADD_COMPONENT_DEPENDENCIES})
foreach(target ${targets})
set_property(TARGET ${target} PROPERTY CXX_STANDARD 17)
target_compile_definitions(${target} PRIVATE "libcaf_${name}_EXPORTS")
target_include_directories(${target} PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_BINARY_DIR}")
if(BUILD_SHARED_LIBS)
set_target_properties(${target} PROPERTIES
CXX_VISIBILITY_PRESET hidden
VISIBILITY_INLINES_HIDDEN ON)
endif()
endforeach()
caf_incubator_export_and_install_lib(${name})
if(CAF_INC_ADD_COMPONENT_ENUM_CONSISTENCY_CHECKS)
foreach(enum_name ${CAF_INC_ADD_COMPONENT_ENUM_CONSISTENCY_CHECKS})
string(REPLACE "." "/" path "${enum_name}")
caf_incubator_add_enum_consistency_check("caf/${path}.hpp"
"src/${path}_strings.cpp")
endforeach()
endif()
endfunction()
# -- provide an uinstall target ------------------------------------------------
# Process cmake_uninstall.cmake.in.
......@@ -214,3 +307,28 @@ endif()
if(CAF_INC_ENABLE_EXAMPLES)
add_subdirectory(examples)
endif()
# -- generate and install .cmake files -----------------------------------------
export(EXPORT CAFIncubatorTargets FILE CAFIncubatorTargets.cmake NAMESPACE CAF::)
install(EXPORT CAFIncubatorTargets
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/CAFIncubator"
NAMESPACE CAF::)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/CAFIncubatorConfigVersion.cmake"
VERSION ${CAF_VERSION}
COMPATIBILITY ExactVersion)
configure_package_config_file(
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/CAFIncubatorConfig.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/CAFIncubatorConfig.cmake"
INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/CAFIncubator")
install(
FILES
"${CMAKE_CURRENT_BINARY_DIR}/CAFIncubatorConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/CAFIncubatorConfigVersion.cmake"
DESTINATION
"${CMAKE_INSTALL_LIBDIR}/cmake/CAFIncubator")
......@@ -2,6 +2,7 @@ add_custom_target(all_examples)
function(add_example folder name)
add_executable(${name} ${folder}/${name}.cpp ${ARGN})
set_property(TARGET ${name} PROPERTY CXX_STANDARD 17)
install(FILES ${folder}/${name}.cpp DESTINATION ${CMAKE_INSTALL_DATADIR}/caf/examples/${folder})
add_dependencies(${name} all_examples)
endfunction()
......
......@@ -2,48 +2,21 @@
file(GLOB_RECURSE CAF_BB_HEADERS "caf/*.hpp")
# -- list cpp files for caf::bb ------------------------------------------------
add_library(libcaf_bb INTERFACE)
target_link_libraries(libcaf_bb INTERFACE CAF::core)
# -- install library and header files ------------------------------------------
# install(FILES "${CMAKE_BINARY_DIR}/caf/detail/bb_export.hpp"
# DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/caf/detail")
install(TARGETS libcaf_bb
EXPORT CAFTargets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT bb
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT bb
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT bb)
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/caf"
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
COMPONENT bb
FILES_MATCHING PATTERN "*.hpp")
# -- build unit tests ----------------------------------------------------------
if(NOT CAF_INC_ENABLE_TESTING)
return()
endif()
add_executable(caf-bb-test test/bb-test.cpp)
caf_incubator_set_default_properties(caf-bb-test)
target_include_directories(caf-bb-test PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/test")
target_compile_definitions(caf-bb-test PRIVATE libcaf_bb_EXPORTS)
target_link_libraries(caf-bb-test PRIVATE CAF::core CAF::test)
caf_incubator_add_test_suites(caf-bb-test
# -- add targets ---------------------------------------------------------------
caf_incubator_add_component(
bb
DEPENDENCIES
INTERFACE
CAF::core
HEADERS
${CAF_BB_HEADERS}
TEST_SOURCES
test/bb-test.cpp
TEST_SUITES
container_source
stream_reader
tokenized_integer_reader
)
tokenized_integer_reader)
# CAF::bb is header-only, so it won't pull in the dependencies for the tests.
target_link_libraries(caf-bb-test PRIVATE CAF::core CAF::internal)
......@@ -2,44 +2,24 @@
file(GLOB_RECURSE CAF_NET_HEADERS "caf/*.hpp")
# -- add consistency checks for enum to_string implementations -----------------
caf_incubator_add_enum_consistency_check("caf/net/basp/connection_state.hpp"
"src/basp/connection_state_strings.cpp")
caf_incubator_add_enum_consistency_check("caf/net/basp/ec.hpp"
"src/basp/ec_strings.cpp")
caf_incubator_add_enum_consistency_check("caf/net/basp/message_type.hpp"
"src/basp/message_type_strings.cpp")
caf_incubator_add_enum_consistency_check("caf/net/operation.hpp"
"src/basp/operation_strings.cpp")
# -- utility function for setting default properties ---------------------------
function(caf_net_set_default_properties)
foreach(target ${ARGN})
caf_incubator_set_default_properties(${target})
# Make sure we find our headers plus the the generated export header.
target_include_directories(${target} PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_BINARY_DIR}")
target_compile_definitions(${target} PRIVATE libcaf_net_EXPORTS)
# Pull in public dependencies.
target_link_libraries(${target} PUBLIC CAF::core)
if(MSVC)
target_link_libraries(${target} PUBLIC ws2_32 iphlpapi)
endif()
endforeach()
endfunction()
# -- add library targets -------------------------------------------------------
add_library(libcaf_net_obj OBJECT ${CAF_NET_HEADERS}
#src/actor_proxy_impl.cpp
#src/basp/application.cpp
#src/endpoint_manager.cpp
#src/net/backend/tcp.cpp
#src/net/backend/test.cpp
#src/net/endpoint_manager_queue.cpp
# -- add targets ---------------------------------------------------------------
caf_incubator_add_component(
net
DEPENDENCIES
PUBLIC
CAF::core
$<$<CXX_COMPILER_ID:MSVC>:ws2_32>
PRIVATE
CAF::internal
ENUM_CONSISTENCY_CHECKS
net.basp.connection_state
net.basp.ec
net.basp.message_type
net.operation
HEADERS
${CAF_NET_HEADERS}
SOURCES
src/basp/connection_state_strings.cpp
src/basp/ec_strings.cpp
src/basp/message_type_strings.cpp
......@@ -68,80 +48,17 @@ add_library(libcaf_net_obj OBJECT ${CAF_NET_HEADERS}
src/tcp_stream_socket.cpp
src/udp_datagram_socket.cpp
src/worker.cpp
)
add_library(libcaf_net "${PROJECT_SOURCE_DIR}/cmake/dummy.cpp"
$<TARGET_OBJECTS:libcaf_net_obj>)
generate_export_header(libcaf_net
EXPORT_MACRO_NAME CAF_NET_EXPORT
EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/caf/detail/net_export.hpp")
set_property(TARGET libcaf_net_obj PROPERTY POSITION_INDEPENDENT_CODE ON)
caf_net_set_default_properties(libcaf_net_obj libcaf_net)
target_include_directories(libcaf_net INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>)
add_library(CAF::net ALIAS libcaf_net)
set_target_properties(libcaf_net PROPERTIES
EXPORT_NAME net
SOVERSION ${CAF_VERSION}
VERSION ${CAF_LIB_VERSION}
OUTPUT_NAME caf_net)
# -- install library and header files ------------------------------------------
install(FILES "${CMAKE_BINARY_DIR}/caf/detail/net_export.hpp"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/caf/detail")
install(TARGETS libcaf_net
EXPORT CAFTargets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT net
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT net
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT net)
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/caf"
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
COMPONENT net
FILES_MATCHING PATTERN "*.hpp")
# -- build unit tests ----------------------------------------------------------
if(NOT CAF_INC_ENABLE_TESTING)
return()
endif()
add_executable(caf-net-test
TEST_SOURCES
test/net-test.cpp
$<TARGET_OBJECTS:libcaf_net_obj>)
caf_net_set_default_properties(caf-net-test)
target_include_directories(caf-net-test PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/test")
target_link_libraries(caf-net-test PRIVATE CAF::test)
caf_incubator_add_test_suites(caf-net-test
TEST_SUITES
accept_socket
#application
convert_ip_endpoint
datagram_socket
detail.rfc6455
#datagram_transport
#doorman
#endpoint_manager
header
ip
multiplexer
net.actor_shell
#net.backend.tcp
#net.basp.message_queue
#net.basp.ping_pong
#net.basp.worker
net.length_prefix_framing
net.typed_actor_shell
net.web_socket_server
......@@ -149,12 +66,7 @@ caf_incubator_add_test_suites(caf-net-test
pipe_socket
socket
socket_guard
#stream_application
stream_socket
stream_transport
#string_application
tcp_sockets
#transport_worker
#transport_worker_dispatcher
udp_datagram_socket
)
udp_datagram_socket)
......@@ -6,6 +6,7 @@
#include "caf/byte.hpp"
#include "caf/detail/net_export.hpp"
#include "caf/fwd.hpp"
#include <cstdint>
#include <vector>
......
......@@ -7,6 +7,7 @@
#include <memory>
#include "caf/intrusive_ptr.hpp"
#include "caf/type_id.hpp"
namespace caf::net {
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment