CMakeLists.txt

cmake_minimum_required(VERSION 3.14)

project(cpp-lazy
        VERSION 9.0.0
        DESCRIPTION
        "A fast C++11/14/17/20 header only library for lazy evaluation and function tools"
        HOMEPAGE_URL "https://github.com/Kaaserne/cpp-lazy"
        LANGUAGES CXX)

# ---- Warning guard ----
# Protect dependents from this project's warnings if the guard isn't disabled
set(cpp-lazy_warning_guard "SYSTEM")
if(cpp-lazy_INCLUDE_WITHOUT_SYSTEM)
    set(cpp-lazy_warning_guard "")
endif()

include(GNUInstallDirs)
set(CPP_LAZY_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE STRING "Installation directory of the include files")

option(CPP_LAZY_USE_STANDALONE "Standalone library without {fmt}" NO)
option(CPP_LAZY_USE_INSTALLED_FMT "Import {fmt} using find_package" NO)
option(CPP_LAZY_USE_MODULES "Enable C++20's modules" NO)

if (NOT DEFINED CPP_LAZY_DEBUG_ASSERTIONS)
    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        set(CPP_LAZY_DEBUG_ASSERTIONS ON)
    else()
        set(CPP_LAZY_DEBUG_ASSERTIONS OFF)
    endif()
endif()
option(CPP_LAZY_DEBUG_ASSERTIONS "Debug assertions" ${CPP_LAZY_DEBUG_ASSERTIONS})

if (CPP_LAZY_USE_MODULES)
	message(STATUS "cpp-lazy: using C++20 modules")
	set(CMAKE_DEBUG_POSTFIX "d")
	set(CPP_LAZY_SOURCE_FILES "src/lz.cppm")
	set(CPP_LAZY_LINK_VISIBILITY "PUBLIC")
	set(CPP_LAZY_COMPILE_FEATURES_VISIBLITY "PUBLIC")
	set(CPP_LAZY_COMPILE_DEFINITIONS_VISIBLITY "PRIVATE")
	set(CPP_LAZY_COMPILE_INCLUDE_VISIBLITY "PUBLIC")
	set(CMAKE_CXX_SCAN_FOR_MODULES ON)
else()
	set(CPP_LAZY_LIB_TYPE "INTERFACE")
	set(CPP_LAZY_LINK_VISIBILITY "INTERFACE")
	set(CPP_LAZY_COMPILE_FEATURES_VISIBLITY "INTERFACE")
	set(CPP_LAZY_COMPILE_DEFINITIONS_VISIBLITY "INTERFACE")
	set(CPP_LAZY_COMPILE_INCLUDE_VISIBLITY "INTERFACE")
endif()

# ---- Import {fmt} ----
if (CPP_LAZY_USE_STANDALONE)
	message(STATUS "cpp-lazy: using standalone version")
else()
	if (CPP_LAZY_USE_INSTALLED_FMT)
		message(STATUS "cpp-lazy: using external {fmt} library")
		set(CPP_LAZY_FMT_DEP_VERSION "" CACHE STRING "Version of {fmt} to use")
		find_package(fmt ${CPP_LAZY_FMT_DEP_VERSION} REQUIRED CONFIG)
	else()
		message(STATUS "cpp-lazy: using bundled {fmt} library")
		set(FMT_OS YES CACHE INTERNAL "")
		set(FMT_INSTALL YES CACHE INTERNAL "" FORCE)
		include(FetchContent)
		set(CPP_LAZY_FMT_DEP_VERSION 12.1.0 CACHE STRING "Version of {fmt} to use")
		FetchContent_Declare(fmt 
			URL https://github.com/fmtlib/fmt/archive/refs/tags/${CPP_LAZY_FMT_DEP_VERSION}.tar.gz 
			UPDATE_DISCONNECTED YES 
			DOWNLOAD_EXTRACT_TIMESTAMP TRUE
		)
		FetchContent_MakeAvailable(fmt)
	endif()
endif()

message(STATUS "cpp-lazy: standalone version: ${CPP_LAZY_USE_STANDALONE}.")
message(STATUS "cpp-lazy: debug assertions: ${CPP_LAZY_DEBUG_ASSERTIONS}.")

# ---- Declare library ----
add_library(cpp-lazy ${CPP_LAZY_LIB_TYPE} "${CPP_LAZY_SOURCE_FILES}")
add_library(cpp-lazy::cpp-lazy ALIAS cpp-lazy)

if (CPP_LAZY_USE_MODULES)
	target_sources(cpp-lazy PUBLIC
		FILE_SET cxx_modules
		TYPE
			CXX_MODULES
		FILES "${CPP_LAZY_SOURCE_FILES}")
	target_compile_features(cpp-lazy PRIVATE cxx_std_20)
endif()

# Link lib stacktrace if debug assertions are enabled, on Linux with C++23 or later
set(IS_CXX_23 $<VERSION_GREATER_EQUAL:${CMAKE_CXX_STANDARD},23>)
set(IS_GNU_LIKE_COMPILER $<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>)
set(LZ_LINK_LIBBACKTRACE_CONDITION
    $<AND:$<BOOL:${CPP_LAZY_DEBUG_ASSERTIONS}>,${IS_GNU_LIKE_COMPILER},${IS_CXX_23}>
)
target_link_libraries(cpp-lazy ${CPP_LAZY_LINK_VISIBILITY}
	$<$<NOT:$<BOOL:${CPP_LAZY_USE_STANDALONE}>>:fmt::fmt>
	$<${LZ_LINK_LIBBACKTRACE_CONDITION}:stdc++_libbacktrace>
)
target_compile_definitions(cpp-lazy ${CPP_LAZY_COMPILE_DEFINITIONS_VISIBLITY}
	$<$<BOOL:${CPP_LAZY_USE_STANDALONE}>:LZ_STANDALONE>
	$<$<BOOL:${CPP_LAZY_DEBUG_ASSERTIONS}>:LZ_DEBUG_ASSERTIONS>
)

target_include_directories(cpp-lazy	${cpp-lazy_warning_guard}
	${CPP_LAZY_COMPILE_INCLUDE_VISIBLITY}
        "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
		"$<INSTALL_INTERFACE:${CPP_LAZY_INCLUDE_DIR}>"
)

# ---- Install ----
include(CMakePackageConfigHelpers)

set(cpp-lazy_install_cmakedir "${CMAKE_INSTALL_LIBDIR}/cmake/cpp-lazy")

option(CPP_LAZY_INSTALL "Install cpp-lazy" OFF)

if (CPP_LAZY_USE_MODULES AND CPP_LAZY_INSTALL)
	install(
		TARGETS cpp-lazy
        EXPORT cpp-lazyTargets
        INCLUDES DESTINATION "${CMAKE_INSTALL_LIBDIR}"
        FILE_SET cxx_modules
		DESTINATION "${CMAKE_INSTALL_LIBDIR}"
	)
elseif (CPP_LAZY_INSTALL)
	install(
		TARGETS cpp-lazy
		EXPORT cpp-lazyTargets
		INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
	)
endif()

if (CPP_LAZY_INSTALL)
	# ---- pkg-config (.pc) ----
	set(PC_REQUIRES "")
	if (NOT CPP_LAZY_USE_STANDALONE)
		set(PC_REQUIRES "fmt")
	endif()

	set(PC_LIBS "")
	set(PC_LIBS_PRIVATE "")
	if (CPP_LAZY_USE_MODULES)
		set(PC_LIBS "-lcpp-lazy")
	endif()
	if (CPP_LAZY_DEBUG_ASSERTIONS AND IS_GNU_LIKE_COMPILER)
		set(PC_LIBS_PRIVATE "${PC_LIBS_PRIVATE} -lstdc++_libbacktrace")
	endif()

	configure_file(
		"${PROJECT_SOURCE_DIR}/cmake/cpp-lazy.pc.in"
		"${PROJECT_BINARY_DIR}/cpp-lazy.pc"
		@ONLY
	)

	install(
		FILES "${PROJECT_BINARY_DIR}/cpp-lazy.pc"
		DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
	)

	# ---- CMake config files ----
	write_basic_package_version_file(
		cpp-lazyConfigVersion.cmake
		VERSION ${PROJECT_VERSION}
		COMPATIBILITY SameMajorVersion
		ARCH_INDEPENDENT
	)
	configure_package_config_file(
		"${PROJECT_SOURCE_DIR}/cmake/cpp-lazyConfig.cmake.in"
		"${PROJECT_BINARY_DIR}/cpp-lazyConfig.cmake"
		INSTALL_DESTINATION "${cpp-lazy_install_cmakedir}"
	)

	install(EXPORT cpp-lazyTargets
			NAMESPACE cpp-lazy::
			DESTINATION "${cpp-lazy_install_cmakedir}"
	)
	install(FILES
			"${PROJECT_BINARY_DIR}/cpp-lazyConfig.cmake"
			"${PROJECT_BINARY_DIR}/cpp-lazyConfigVersion.cmake"
			DESTINATION "${cpp-lazy_install_cmakedir}"
	)
	
	install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/"
			DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
	)
	include(CPack)
	set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_NAME}/${CPACK_PACKAGE_VERSION}")
	set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE.md")
endif()