CMakeLists.txt.in

cmake_minimum_required(VERSION 3.20)
set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "Minimum OS X deployment version")

project(CASMcode_configuration VERSION 2.0.0 LANGUAGES CXX)

# set CMAKE_INSTALL_X variables
include(GNUInstallDirs)

# specify the C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED True)

# try to use ccache
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
endif()

##############################################
## Find dependencies

# Should find ZLIB::ZLIB
find_package(ZLIB)

# Find CASM
if(NOT DEFINED CASM_PREFIX)
  message(STATUS "CASM_PREFIX not defined")
  # try to find Python
  find_package (Python COMPONENTS Interpreter Development)
  if(DEFINED Python_EXECUTABLE)
    # if Python found, obtain CASM_PREFIX from the libcasm.casmglobal
    message(STATUS "found Python_EXECUTABLE: ${Python_EXECUTABLE}")
    message(STATUS "checking for libcasm-global")
    execute_process(
      COMMAND pip show libcasm-global
      RESULT_VARIABLE EXIT_CODE
      OUTPUT_QUIET
    )
    if (${EXIT_CODE} EQUAL 0)
      message(STATUS "found libcasm-global")
      execute_process(COMMAND ${Python_EXECUTABLE} -m libcasm.casmglobal --prefix
                      OUTPUT_VARIABLE CASM_PREFIX_RAW)
      string(STRIP ${CASM_PREFIX_RAW} CASM_PREFIX)
      message(STATUS "CASM_PREFIX: ${CASM_PREFIX}")
    else()
      message(STATUS "did not find libcasm-global")
    endif()
  endif()
endif()
if(DEFINED CASM_PREFIX)
  set(CASMcode_global_ROOT ${CASM_PREFIX}/share/CASMcode_global/cmake)
  set(CASMcode_crystallography_ROOT ${CASM_PREFIX}/share/CASMcode_crystallography/cmake)
  set(CASMcode_clexulator_ROOT ${CASM_PREFIX}/share/CASMcode_clexulator/cmake)
endif()

find_package(CASMcode_global)
if(NOT CASMcode_global_FOUND)
  message(FATAL_ERROR "CMake failed to find CASMcode_global")
endif()
# if successful, we have CASM::casm_global

find_package(CASMcode_crystallography)
if(NOT CASMcode_crystallography_FOUND)
  message(FATAL_ERROR "CMake failed to find CASMcode_crystallography")
endif()
# if successful, we have CASM::casm_crystallography

find_package(CASMcode_clexulator)
if(NOT CASMcode_clexulator_FOUND)
  message(FATAL_ERROR "CMake failed to find CASMcode_clexulator")
endif()
# if successful, we have CASM::casm_clexulator

# if no user CMAKE_INSTALL_PREFIX, use CASM_PREFIX if it exists
IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
  if(DEFINED CASM_PREFIX)
    message(STATUS "CMAKE_INSTALL_PREFIX initialized to default, so updating CMAKE_INSTALL_PREFIX to CASM_PREFIX")
    set(CMAKE_INSTALL_PREFIX ${CASM_PREFIX} CACHE PATH "set CMAKE_INSTALL_PREFIX to CASM_PREFIX" FORCE)
    message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
  endif()
ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)

##############################################
## Build libcasm_configuration

# create libcasm_configuration
set(
  libcasm_configuration_HEADERS
@header_files@)
set(
  libcasm_configuration_SOURCES
@source_files@)
add_library(casm_configuration SHARED ${libcasm_configuration_SOURCES})
target_include_directories(casm_configuration
  PUBLIC
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/casm/external>
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/casm/external/gzstream>
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/casm/external>
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/casm/external/gzstream>
)
target_compile_options(casm_configuration
  PUBLIC
    "-DCASM_CONFIGURATION_TXT_VERSION=\"${CMAKE_PROJECT_VERSION}\""
    -DEIGEN_DEFAULT_DENSE_INDEX_TYPE=long
    -DGZSTREAM_NAMESPACE=gz
)
target_link_libraries(casm_configuration
  ZLIB::ZLIB
  ${CMAKE_DL_LIBS}
  CASM::casm_global
  CASM::casm_crystallography
  CASM::casm_clexulator
)
if(APPLE)
  set_target_properties(
    casm_configuration PROPERTIES INSTALL_RPATH "@loader_path")
else()
  set_target_properties(
    casm_configuration PROPERTIES INSTALL_RPATH "$ORIGIN")
endif()


##############################################
## Install libcasm_configuration

# install header files in <prefix>/libcasm/include/,
# while preserving directory structure
foreach ( filevar ${libcasm_configuration_HEADERS} )
  file(RELATIVE_PATH relfile ${PROJECT_SOURCE_DIR}/include/ ${filevar})
  get_filename_component( reldir ${relfile} DIRECTORY )
  install( FILES ${filevar} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${reldir} )
endforeach()

# install libcasm_configuration in <prefix>/libcasm/lib/
install(
  TARGETS casm_configuration
  EXPORT CASMcode_configurationTargets
  DESTINATION lib)

##############################################
## Python extensions

# The CMake package config and target files are installed under the Python
# package root. This is necessary to ensure that all the relative paths in the
# helloTargets.cmake resolve correctly. It also provides encapsulation.
#
# The actual path used must be selected so that consuming projects can locate it
# via `find_package`. To support finding CMake packages in the Python package
# prefix, using `find_package`s default search path of
# `<prefix>/<name>/share/<name>*/cmake/` is reasonable. Adding the Python
# package installation prefix to CMAKE_PREFIX_PATH in combination with this path
# will allow `find_package` to find this package and any other package installed
# via a Python package if the CMake and Python packages are named the same.
set(CASM_CMAKE_PACKAGE_INSTALL_SUBDIR "share/CASMcode_configuration/cmake")

install(
  EXPORT CASMcode_configurationTargets
  NAMESPACE CASM::
  DESTINATION ${CASM_CMAKE_PACKAGE_INSTALL_SUBDIR})

include(CMakePackageConfigHelpers)

write_basic_package_version_file(
  CASMcode_configurationConfigVersion.cmake
  VERSION ${PROJECT_VERSION}
  COMPATIBILITY SameMinorVersion)

configure_package_config_file(
  "${PROJECT_SOURCE_DIR}/cmake/CASMcode_configurationConfig.cmake.in" CASMcode_configurationConfig.cmake
  INSTALL_DESTINATION ${CASM_CMAKE_PACKAGE_INSTALL_SUBDIR})

install(FILES "${PROJECT_BINARY_DIR}/CASMcode_configurationConfig.cmake"
              "${PROJECT_BINARY_DIR}/CASMcode_configurationConfigVersion.cmake"
        DESTINATION ${CASM_CMAKE_PACKAGE_INSTALL_SUBDIR})

# We are using the SKBUILD variable, which is defined when scikit-build is
# running the CMake build, to control building the Python wrapper. This allows
# the C++ project to be installed, standalone, when using the standard CMake
# build flow.
if(DEFINED SKBUILD)

  # call pybind11-config to obtain the root of the cmake package
  execute_process(COMMAND ${PYTHON_EXECUTABLE} -m pybind11 --cmakedir
                  OUTPUT_VARIABLE pybind11_ROOT_RAW)
  string(STRIP ${pybind11_ROOT_RAW} pybind11_ROOT)
  find_package(pybind11)

  # The extension modules must load:
  # - the casm_global library
  # - the casm_crystallography library
  # - the casm_clexulator library
  # - the casm_configuration library
  # They can be found by setting a relative rpath

  ### libcasm.clusterography._clusterography ###
  pybind11_add_module(_clusterography MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/clusterography.cpp")
  target_link_libraries(_clusterography PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _clusterography DESTINATION clusterography)
  if(APPLE)
    set_target_properties(
      _clusterography PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _clusterography PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

  ### libcasm.configuration._configuration ###
  pybind11_add_module(_configuration MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/configuration.cpp")
  target_link_libraries(_configuration PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _configuration DESTINATION configuration)
  if(APPLE)
    set_target_properties(
      _configuration PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _configuration PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

  ### libcasm.local_configuration._local_configuration ###
  pybind11_add_module(_local_configuration MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/local_configuration.cpp")
  target_link_libraries(_local_configuration PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _local_configuration DESTINATION local_configuration)
  if(APPLE)
    set_target_properties(
      _local_configuration PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _local_configuration PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

  ### libcasm.enumerate._enumerate ###
  pybind11_add_module(_enumerate MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/enumerate.cpp")
  target_link_libraries(_enumerate PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _enumerate DESTINATION enumerate)
  if(APPLE)
    set_target_properties(
      _enumerate PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _enumerate PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

  ### libcasm.irreps._irreps ###
  pybind11_add_module(_irreps MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/irreps.cpp")
  target_link_libraries(_irreps PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _irreps DESTINATION irreps)
  if(APPLE)
    set_target_properties(
      _irreps PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _irreps PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

  ### libcasm.occ_events._occ_events ###
  pybind11_add_module(_occ_events MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/occ_events.cpp")
  target_link_libraries(_occ_events PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _occ_events DESTINATION occ_events)
  if(APPLE)
    set_target_properties(
      _occ_events PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _occ_events PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

  ### libcasm.sym_info._sym_info ###
  pybind11_add_module(_sym_info MODULE
                      "${PROJECT_SOURCE_DIR}/python/src/sym_info.cpp")
  target_link_libraries(_sym_info PRIVATE
    CASM::casm_global
    CASM::casm_crystallography
    CASM::casm_clexulator
    casm_configuration
  )
  install(TARGETS _sym_info DESTINATION sym_info)
  if(APPLE)
    set_target_properties(
      _sym_info PROPERTIES INSTALL_RPATH "@loader_path/../lib")
  else()
    set_target_properties(
      _sym_info PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
  endif()

endif()