CMakeLists.txt

cmake_minimum_required(VERSION 3.16)

project(REST)

# Minimum compiler version
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    # require at least gcc 4.8
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
        message(FATAL_ERROR "GCC version must be at least 4.8!")
    endif ()
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    # require at least clang 3.2
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.2)
        message(FATAL_ERROR "Clang version must be at least 3.2!")
    endif ()
endif ()

if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
else ()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lstdc++fs")
endif (CMAKE_SYSTEM_NAME MATCHES "Darwin")

if (CMAKE_BUILD_TYPE MATCHES "Release")
    message(STATUS "Enabling warnings as errors")
    set(CMAKE_CXX_FLAGS
        "${CMAKE_CXX_FLAGS} -Wall -Werror -Wno-cast-function-type -Wno-unused-function -Wno-unknown-pragmas -Wno-delete-non-virtual-dtor"
    )
endif (CMAKE_BUILD_TYPE MATCHES "Release")

if (CMAKE_BUILD_TYPE MATCHES "Debug")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
endif (CMAKE_BUILD_TYPE MATCHES "Debug")

# https://github.com/rest-for-physics/framework/issues/162 &
# https://github.com/rest-for-physics/framework/issues/236
if (${CMAKE_VERSION} VERSION_LESS "3.23")
    cmake_policy(SET CMP0082 OLD)
endif ()

# Install path
if (NOT DEFINED INSTALL_PREFIX)
    if (DEFINED ENV{REST_PATH})
        set(INSTALL_PREFIX $ENV{REST_PATH})
    else ()
        set(INSTALL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/install)
    endif ()
endif ()
get_filename_component(INSTALL_PREFIX_ABSOLUTE ${INSTALL_PREFIX} ABSOLUTE
                       BASE_DIR "${CMAKE_BINARY_DIR}")
set(REST_PATH ${INSTALL_PREFIX_ABSOLUTE})
if (CMAKE_INSTALL_PREFIX STREQUAL "/usr/local")
    message(
        FATAL_ERROR
            "An install location has not been defined!  Please, define an installation directory using -DCMAKE_INSTALL_PREFIX. Do not use a system directory as installation path (such as /usr/local/). REST has not been designed to be installed as system libraries. \n Re-run cmake again using : cmake -DCMAKE_INSTALL_PREFIX=../install ..\n"
    )

    set(CMAKE_INSTALL_PREFIX ${INSTALL_PREFIX_ABSOLUTE})
endif ()

# Welcome message
if (NOT DEFINED REST_WELCOME)
    set(REST_WELCOME ON)
endif ()

set(external_include_dirs)
set(external_libs)

if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
    set(external_include_dirs ${external_include_dirs} "/usr/local/include/")
    message(STATUS "Adding BREW include directory: /usr/local/include")
endif (CMAKE_SYSTEM_NAME MATCHES "Darwin")

set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${DECAY_PATH}/cmake
                      ${CMAKE_MODULE_PATH})
set(CMAKE_MACOSX_RPATH 1)

# ROOT libs and includes  #####
find_package(ROOT 6.24 REQUIRED)
set(ROOT_REQUIRED_LIBRARIES
    Core
    RIO
    Geom
    Gdml
    Minuit
    Spectrum
    XMLIO)

# Auto schema evolution for ROOT
if (NOT DEFINED REST_SE)
    set(REST_SE ON)
endif ()
set(SCHEMA_EVOLUTION ${REST_SE})

# Switch to enable ROOT Eve functionality.
if (NOT DEFINED REST_EVE)
    set(REST_EVE ON)
endif ()
if (${REST_EVE} MATCHES "ON")
    add_definitions(-DUSE_Eve)
    list(APPEND rest_features "Eve")
    set(ROOT_REQUIRED_LIBRARIES ${ROOT_REQUIRED_LIBRARIES} Eve RGL Gui)
else ()
    set(excludes ${excludes} TRestEveEventViewer)
endif (${REST_EVE} MATCHES "ON")

find_package(ROOT REQUIRED COMPONENTS ${ROOT_REQUIRED_LIBRARIES})

message(STATUS "ROOT LIBRARIES: ${ROOT_LIBRARIES}")

set(ROOTCINT_EXECUTABLE ${ROOT_rootcint_CMD})

set(external_libs "${external_libs};${ROOT_LIBRARIES}")

if (CMAKE_SYSTEM_NAME MATCHES "Windows")
    set(external_libs "${external_libs};Ws2_32")
    set(CMAKE_CXX_STANDARD 17)
    add_definitions(-D_HAS_STD_BYTE=0)
else ()

    if (NOT CMAKE_SYSTEM_NAME MATCHES "Darwin")
        set(external_libs "${external_libs};stdc++fs")
    endif ()

    execute_process(COMMAND root-config --has-cxx20 OUTPUT_VARIABLE HASCXX20)
    execute_process(COMMAND root-config --has-cxx17 OUTPUT_VARIABLE HASCXX17)
    execute_process(COMMAND root-config --has-cxx14 OUTPUT_VARIABLE HASCXX14)
    execute_process(COMMAND root-config --has-cxx11 OUTPUT_VARIABLE HASCXX11)

    execute_process(COMMAND root-config --cflags OUTPUT_VARIABLE ROOT_CFLAGS)

    set(CMAKE_CXX_STANDARD_REQUIRED YES)

    if (${HASCXX20} MATCHES "yes")
        set(CMAKE_CXX_STANDARD 20)
    elseif (${HASCXX17} MATCHES "yes")
        set(CMAKE_CXX_STANDARD 17)
    else ()
        message(
            FATAL_ERROR
                "Minimum C++ standard version is 17,
                while the root version is compiled with an older
                C++ standard, check root-config --cflags ${ROOT_CFLAGS}")
    endif ()
endif ()

set(external_include_dirs ${external_include_dirs} ${ROOT_INCLUDE_DIRS})

# mySQL  ##### This is to enable linking of SQL libraries. I.e. for process
# TRestSQLToAnalysisProcess.
if (NOT DEFINED REST_SQL)
    set(REST_SQL OFF)
endif ()
if (${REST_SQL} MATCHES "ON")
    list(APPEND rest_features "mySQL")
    add_definitions(-DUSE_SQL)
    include(FindSQL)
    set(external_include_dirs ${external_include_dirs} ${SQL_INCLUDE_DIR})
    set(external_libs "${external_libs} ${SQL_LIBRARIES}")
    message(STATUS "SQL include directory: " ${SQL_INCLUDE_DIR})
    set(SQL ON)
else ()
    set(REST_SQL OFF)
endif (${REST_SQL} MATCHES "ON")

# MPFR  #####
if (NOT DEFINED REST_MPFR)
    set(REST_MPFR OFF)
endif ()
if (${REST_MPFR} MATCHES "ON")
    find_path(MPFR_INCLUDE mpfr.h HINTS ${MPFR_PATH} ${MPFR_PATH}/include
    )# path to include directory
    find_path(MPFR_LIB_PATH libmpfr.so HINTS ${MPFR_PATH} ${MPFR_PATH}/lib)
    find_library(MPFR_LIB mpfr HINTS ${MPFR_PATH} ${MPFR_PATH}/lib) # path to
                                                                    # .so
    # file
    if (NOT MPFR_INCLUDE MATCHES "MPFR_INCLUDE-NOTFOUND"
        AND NOT MPFR_LIB MATCHES "MPFR_LIB-NOTFOUND")
        # MPFR is found
        list(APPEND rest_features "MPFR")
        add_compile_definitions(USE_MPFR)
        set(external_include_dirs ${external_include_dirs} ${MPFR_INCLUDE})
        set(external_libs "${external_libs};${MPFR_LIB}")
        link_directories(${MPFR_LIB})
        message(STATUS "MPFR library : ${MPFR_LIB}")
    else ()
        message(
            ERROR
            "MPFR library was not found. Adding the location to the installation path may solve this problem.\n Use -DMPFR_PATH=/path/to/mpfr/"
        )
    endif ()
else ()
    set(REST_MPFR OFF)
endif (${REST_MPFR} MATCHES "ON")

if (((${REST_ALL_LIBS} MATCHES "ON") AND (NOT DEFINED RESTLIB_AXION))
    OR (${RESTLIB_AXION} MATCHES "ON"))
    # GSL #### Find GSL
    find_package(GSL REQUIRED)

    # Include GSL directories
    set(external_include_dirs ${external_include_dirs} ${GSL_INCLUDE_DIRS})

    # Link GSL libraries
    set(external_libs ${external_libs};${GSL_LIBRARIES})

    message(STATUS "Found GSL libraries : ${GSL_LIBRARIES}")
    message(STATUS "GSL headers : ${GSL_INCLUDE_DIRS}")

    set(REST_GSL ON)
else ()
    set(REST_GSL OFF)
    message(STATUS "GSL libraries not required")
endif (((${REST_ALL_LIBS} MATCHES "ON") AND (NOT DEFINED RESTLIB_AXION))
       OR (${RESTLIB_AXION} MATCHES "ON"))

# CURL  #####
find_library(CURL_LIB curl)
if (NOT ${CURL_LIB} STREQUAL "CURL_LIB-NOTFOUND")
    list(APPEND rest_features "CURL")
    add_compile_definitions(USE_Curl)
    message(STATUS "Found curl library: ${CURL_LIB}")
    set(external_libs "${external_libs};-lcurl")
else ()
    message(WARNING "CURL library was not found. ")
endif ()

# Include directories for compilation
include_directories(${external_include_dirs})
message(STATUS "external include directory: " ${external_include_dirs})
message(STATUS "external libraries to link: " ${external_libs})

# Gather some information
string(TIMESTAMP date "%Y-%m-%d %H:%M")

# Enable testing (-DTEST=ON flag, it is OFF by default)
include(Testing)

# Start compile
include(MacroRootDict)

# uninstall target
if (NOT TARGET uninstall)
    configure_file(
        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)

    add_custom_target(
        uninstall COMMAND ${CMAKE_COMMAND} -P
                          ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
endif ()

# Clear the install dir
if (NOT DEFINED INSTALL_CLEARDIR)
    set(INSTALL_CLEARDIR ON)
endif ()
if (${INSTALL_CLEARDIR} MATCHES "ON")
    install(
        CODE "execute_process(COMMAND \"${CMAKE_COMMAND}\" -P \"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake\")"
    )
endif ()

# Compile and install for each subdir
add_subdirectory(source)

message("")
message(STATUS "rest libraries: " ${rest_libraries_regular})
message(STATUS "rest executables: " ${rest_exes_str})
message(STATUS "rest macros: " ${rest_macros_str})
message("")

# Begin installation
message("")
message("REST will be installed in: ${CMAKE_INSTALL_PREFIX}")
message("===========================================================")
message("System is: ${CMAKE_SYSTEM_NAME}")
message("Packages: ${rest_packages}")
message("Libraries: ${rest_libraries}")
message("Features: ${rest_features}")
message("===========================================================")
message(
    "Check main project README.md to see all available compilation options, packages and libraries"
)
message("")

file(GLOB_RECURSE Headers "${CMAKE_CURRENT_SOURCE_DIR}/source/framework/*.h")

# Install the files of the main framework
install(FILES ${Headers} DESTINATION include)
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/LICENCE DESTINATION .)
install(
    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/examples
    DESTINATION .
    COMPONENT install)
install(
    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/macros
    DESTINATION .
    COMPONENT install)
install(
    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/data
    DESTINATION .
    COMPONENT install)
install(
    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/cmake/scripts
    DESTINATION .
    COMPONENT install)
file(GLOB cmake_scripts "cmake/scripts/*")
install(FILES ${cmake_scripts} DESTINATION cmake)

if (CMAKE_SYSTEM_NAME MATCHES "Windows") # we must call library install here in
    # windows
    foreach (lib ${rest_libraries})
        install(
            TARGETS ${lib}
            RUNTIME DESTINATION bin
            LIBRARY DESTINATION bin
            ARCHIVE DESTINATION lib)
    endforeach ()

    foreach (exe ${rest_exes})
        install(
            TARGETS ${exe}
            RUNTIME DESTINATION bin
            LIBRARY DESTINATION bin
            ARCHIVE DESTINATION lib)
    endforeach ()

else ()

    add_subdirectory(python-bindings)

    # Create thisREST.sh
    include(thisREST)

    # Add permissions
    install(
        CODE "execute_process(COMMAND chmod 755 ${CMAKE_INSTALL_PREFIX}/bin/rest-config)"
    )
    install(CODE "execute_process(COMMAND chmod 755 ${CMAKE_INSTALL_PREFIX})")

endif ()

if (CMAKE_SYSTEM_NAME MATCHES "Darwin") # we must call library install here in
    # MacOs
    foreach (lib ${rest_libraries})
        install(
            TARGETS ${lib}
            RUNTIME DESTINATION bin
            LIBRARY DESTINATION bin
            ARCHIVE DESTINATION lib)
    endforeach ()

    foreach (exe ${rest_exes})
        install(
            TARGETS ${exe}
            RUNTIME DESTINATION bin
            LIBRARY DESTINATION bin
            ARCHIVE DESTINATION lib)
    endforeach ()

endif ()

# Copy pcm files
if (CMAKE_SYSTEM_NAME MATCHES "Windows")

    # Copy pcm files to bin
    install(
        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/rootdict/
        DESTINATION bin
        FILES_MATCHING
        PATTERN "*.pcm")
else ()

    # Copy pcm files to lib
    install(
        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/rootdict/
        DESTINATION lib
        FILES_MATCHING
        PATTERN "*.pcm")

endif ()