diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst new file mode 100644 index 0000000..3e97a39 --- /dev/null +++ b/CONTRIBUTING.rst @@ -0,0 +1,31 @@ +=========================================== +Contributing to SCINE Development Utilities +=========================================== + +Contribution Process +==================== + +The development for this code is done in a private repository maintained by the +Reiher Research Group. GitHub is only used for the official releases. + +If you would like to contribute a larger change, please write to scine@phys.chem.ethz.ch. +For smaller changes, you can create a pull request on GitHub. If we agree with +the changes, a member of the Reiher Research Group will include them in our +development code. Of course, we will give proper acknowledgment for any external +contribution (see below for a list of all contributors). As soon as these changes +are available in an official release, we will close the corresponding pull requests +and/or issues on GitHub. + +Please note that contributing a small change does in no way mean that you will +be added to the author list of a future paper and/or Zenodo entry! + +Main Contributors +================= + +Almost all contributions to SCINE in general and this repository in specific come +from members of the Reiher research group. + +Further Contributors +==================== + +So far, no one else has contributed to this repository. diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..c548b5d --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,26 @@ +Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.rst b/README.rst new file mode 100644 index 0000000..fd344be --- /dev/null +++ b/README.rst @@ -0,0 +1,15 @@ +============================= +SCINE - Development Utilities +============================= + +Introduction +============ + +This repository contains scripts and other stuff useful in all SCINE projects. + +License and Copyright Information +================================= + +This work is (unless stated otherwise) distributed under the BSD 3-clause "New" +or "Revised" License. For more license and copyright information, see the file +``LICENSE.txt`` in this repository. diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/cmake/AddEigen.cmake b/cmake/AddEigen.cmake new file mode 100644 index 0000000..d6b4956 --- /dev/null +++ b/cmake/AddEigen.cmake @@ -0,0 +1,103 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +# If the target already exists, do nothing +if(NOT TARGET Eigen3::Eigen) + find_package(Eigen3 3.3.2 REQUIRED) +endif() + +option(SCINE_USE_INTEL_MKL "Use the Intel MKL libraries with Eigen" ON) +option(SCINE_USE_LAPACK "Use a LAPACK library with Eigen" ON) +option(SCINE_USE_BLAS "Use a BLAS library with Eigen" ON) + +# Attempt to find external linalg libraries that accelerate basic calls in +# the following order: +# +# 1. Intel MKL +# 2. LAPACK (brings BLAS too) +# 3. BLAS +# +if(NOT ADD_EIGEN_SEARCHED_EXTERNAL_LINALG_LIBRARIES) + if(SCINE_USE_INTEL_MKL) + include(FindMKL) + endif() + + if(MKL_FOUND) + find_package(OpenMP REQUIRED) + message(STATUS "Found MKL for use with Eigen3") + else() + if(SCINE_USE_LAPACK) + include(FindLAPACK) + find_package(LAPACK QUIET) + endif() + + if(LAPACK_FOUND) + message(STATUS "Found LAPACK/BLAS for use with Eigen3") + else() + if(SCINE_USE_BLAS) + include(FindBLAS) + find_package(BLAS QUIET) + endif() + + if(BLAS_FOUND) + message(STATUS "Found BLAS for use with Eigen3") + endif() + endif() + endif() + + set(ADD_EIGEN_SEARCHED_EXTERNAL_LINALG_LIBRARIES TRUE) +endif() + +function(add_eigen target_name mode) + # Everything relating to the special case of object libraries can be + # simplified down to the target_link_libraries command when the minimum cmake + # version is bumped past 3.12.0 + if("${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.12.0") + set(_CAN_LINK_OBJECT_LIBRARIES TRUE) + endif() + get_target_property(target_type ${target_name} TYPE) + if("${target_type}" STREQUAL "OBJECT_LIBRARY") + set(_IS_OBJECT_LIBRARY TRUE) + endif() + + # Append the required properties to the passed target + if(MKL_FOUND AND SCINE_USE_INTEL_MKL) + # MKL AND EIGEN_USE_MKL_ALL + if(_CAN_LINK_OBJECT_LIBRARIES OR NOT _IS_OBJECT_LIBRARY) + target_link_libraries(${target_name} ${mode} Eigen3::Eigen ${MKL_LIBRARIES} OpenMP::OpenMP_CXX) + else() + target_include_directories(${target_name} ${mode} $) + endif() + target_include_directories(${target_name} ${mode} ${MKL_INCLUDE_DIRS}) + target_compile_definitions(${target_name} ${mode} EIGEN_USE_MKL_ALL) + target_compile_options(${target_name} ${mode} $<$:${OpenMP_CXX_FLAGS}>) + else() + if(LAPACK_FOUND AND SCINE_USE_LAPACK) + # LAPACK and EIGEN_USE_LAPACK / EIGEN_USE_BLAS + if(_CAN_LINK_OBJECT_LIBRARIES OR NOT _IS_OBJECT_LIBRARY) + target_link_libraries(${target_name} ${mode} Eigen3::Eigen ${LAPACK_LIBRARIES}) + endif() + target_compile_definitions(${target_name} ${mode} EIGEN_USE_LAPACK EIGEN_USE_BLAS) + else() + if(BLAS_FOUND AND SCINE_USE_BLAS) + # Blas and EIGEN_USE_BLAS + if(_CAN_LINK_OBJECT_LIBRARIES OR NOT _IS_OBJECT_LIBRARY) + target_link_libraries(${target_name} ${mode} Eigen3::Eigen ${BLAS_LIBRARIES}) + else() + target_include_directories(${target_name} ${mode} $) + endif() + target_compile_definitions(${target_name} ${mode} EIGEN_USE_BLAS) + else() + # Just Eigen, no definitions + if(_CAN_LINK_OBJECT_LIBRARIES OR NOT _IS_OBJECT_LIBRARY) + target_link_libraries(${target_name} ${mode} Eigen3::Eigen) + else() + target_include_directories(${target_name} ${mode} $) + endif() + endif() + endif() + endif() +endfunction() diff --git a/cmake/CMakeBackports.cmake b/cmake/CMakeBackports.cmake new file mode 100644 index 0000000..6218340 --- /dev/null +++ b/cmake/CMakeBackports.cmake @@ -0,0 +1,37 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +function(list_pop_front listname resultname) + if(${CMAKE_VERSION} VERSION_LESS "3.15.0") + if(${listname}) + list(GET ${listname} 0 firstElement) + set(${resultname} ${firstElement} PARENT_SCOPE) + list(REMOVE_AT ${listname} 0) + set(${listname} ${${listname}} PARENT_SCOPE) + endif() + else() + list(POP_FRONT ${listname} ${resultname}) + set(${resultname} ${${resultname}} PARENT_SCOPE) + set(${listname} ${${listname}} PARENT_SCOPE) + endif() +endfunction() + +function(list_pop_back listname resultname) + if(${CMAKE_VERSION} VERSION_LESS "3.15.0") + if(${listname}) + list(LENGTH ${listname} listlength) + math(EXPR lastElementIndex ${listlength}-1) + list(GET ${listname} ${lastElementIndex} lastElement) + set(${resultname} ${lastElement} PARENT_SCOPE) + list(REMOVE_AT ${listname} ${lastElementIndex}) + set(${listname} ${${listname}} PARENT_SCOPE) + endif() + else() + list(POP_BACK ${listname} ${resultname}) + set(${resultname} ${${resultname}} PARENT_SCOPE) + set(${listname} ${${listname}} PARENT_SCOPE) + endif() +endfunction() diff --git a/cmake/ComponentSetup.cmake b/cmake/ComponentSetup.cmake new file mode 100644 index 0000000..9417025 --- /dev/null +++ b/cmake/ComponentSetup.cmake @@ -0,0 +1,82 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +include(DoxygenDocumentation) +include(Utils) + +function(scine_setup_component) +# Set a default build type + set(default_build_type "RelWithDebInfo") + if(NOT CMAKE_BUILD_TYPE) + message(STATUS "Setting build type to default '${default_build_type}'") + set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE + STRING "Choose the type of the build." + FORCE + ) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY + STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo" + ) + endif() + + if(COVERAGE AND ${CMAKE_BUILD_TYPE} STREQUAL "Debug") + set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -coverage" PARENT_SCOPE) + endif() + +# Give default value to parameter LANGUAGES + if(NOT SCINE_SETUP_LANGUAGES) + set(SCINE_SETUP_LANGUAGES CXX) + endif() + + if(NOT SCINE_SETUP_VERSION) + set(SCINE_SETUP_VERSION 3.0.0) + endif() + +# Default SCINE values + set(SCINE_CMAKE_PACKAGE_ROOT "lib/cmake") + set(SCINE_CMAKE_PACKAGE_ROOT "lib/cmake" PARENT_SCOPE) + +# Compilation options + set(CMAKE_CXX_STANDARD 14 PARENT_SCOPE) + option(SCINE_EXTRA_WARNINGS "Compile with an increased amount of compiler generated warnigs." ON) + option(SCINE_WARNINGS_TO_ERRORS "Compile with warnings as errors." OFF) + if( + ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" + OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" + OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "AppleClang" + ) + if (SCINE_EXTRA_WARNINGS) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-comment") + endif() + if (SCINE_WARNINGS_TO_ERRORS) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") + endif() + endif() + set(CMAKE_EXPORT_COMPILE_COMMANDS ON PARENT_SCOPE) + +# Meta-build options + option(BUILD_SHARED_LIBS "Build shared libraries" ON) + option(SCINE_BUILD_TESTS "Build all test executables." ON) + option(SCINE_BUILD_DOCS "Build the documentation." ON) + option(SCINE_BUILD_PYTHON_BINDINGS "Build all available Python bindings" OFF) + option(SCINE_BUILD_GUI_MODULES "Build all available GUI modules" OFF) + option(SCINE_PARALLELIZE "Parallelize algorithms where available" ON) + set(SCINE_MARCH "native" CACHE STRING "Build all components with the -march=native compiler flag.") + + if(NOT "${SCINE_MARCH_WARNING_PRINTED}" AND NOT "${SCINE_MARCH}" STREQUAL "") + message(WARNING "You are compiling Scine components with an architecture-specific ISA: -march=${SCINE_MARCH}. Linking together libraries with mismatched architecture build flags can cause problems, in particular with Eigen. Watch out!") + set(SCINE_MARCH_WARNING_PRINTED ON) + endif() + +# Tests imports + if(SCINE_BUILD_TESTS) + include(ImportGTest) + import_gtest() + endif() + +# Do not search the installation path in subsequent builds + set(CMAKE_FIND_NO_INSTALL_PREFIX ON CACHE BOOL "" FORCE) + +# Utility functions +endfunction() diff --git a/cmake/DownloadProject.CMakeLists.cmake.in b/cmake/DownloadProject.CMakeLists.cmake.in new file mode 100644 index 0000000..f047dfb --- /dev/null +++ b/cmake/DownloadProject.CMakeLists.cmake.in @@ -0,0 +1,17 @@ +# This file is distributed under the OSI-approved MIT License. +# It has been adapted from /~https://github.com/Crascit/DownloadProject . + +cmake_minimum_required(VERSION 3.9) + +project(${DL_ARGS_PROJ}-download NONE) + +include(ExternalProject) +ExternalProject_Add(${DL_ARGS_PROJ}-download + ${DL_ARGS_UNPARSED_ARGUMENTS} + SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" + BINARY_DIR "${DL_ARGS_BINARY_DIR}" + CONFIGURE_COMMAND "" + BUILD_COMMAND "" + INSTALL_COMMAND "" + TEST_COMMAND "" +) diff --git a/cmake/DownloadProject.cmake b/cmake/DownloadProject.cmake new file mode 100644 index 0000000..cb326d7 --- /dev/null +++ b/cmake/DownloadProject.cmake @@ -0,0 +1,178 @@ +# This file is distributed under the OSI-approved MIT License. +# It has been adapted from /~https://github.com/Crascit/DownloadProject . +# +# MODULE: DownloadProject +# +# PROVIDES: +# download_project( PROJ projectName +# [PREFIX prefixDir] +# [DOWNLOAD_DIR downloadDir] +# [SOURCE_DIR srcDir] +# [BINARY_DIR binDir] +# [QUIET] +# ... +# ) +# +# Provides the ability to download and unpack a tarball, zip file, git repository, +# etc. at configure time (i.e. when the cmake command is run). How the downloaded +# and unpacked contents are used is up to the caller, but the motivating case is +# to download source code which can then be included directly in the build with +# add_subdirectory() after the call to download_project(). Source and build +# directories are set up with this in mind. +# +# The PROJ argument is required. The projectName value will be used to construct +# the following variables upon exit (obviously replace projectName with its actual +# value): +# +# projectName_SOURCE_DIR +# projectName_BINARY_DIR +# +# The SOURCE_DIR and BINARY_DIR arguments are optional and would not typically +# need to be provided. They can be specified if you want the downloaded source +# and build directories to be located in a specific place. The contents of +# projectName_SOURCE_DIR and projectName_BINARY_DIR will be populated with the +# locations used whether you provide SOURCE_DIR/BINARY_DIR or not. +# +# The DOWNLOAD_DIR argument does not normally need to be set. It controls the +# location of the temporary CMake build used to perform the download. +# +# The PREFIX argument can be provided to change the base location of the default +# values of DOWNLOAD_DIR, SOURCE_DIR and BINARY_DIR. If all of those three arguments +# are provided, then PREFIX will have no effect. The default value for PREFIX is +# CMAKE_BINARY_DIR. +# +# The QUIET option can be given if you do not want to show the output associated +# with downloading the specified project. +# +# In addition to the above, any other options are passed through unmodified to +# ExternalProject_Add() to perform the actual download, patch and update steps. +# The following ExternalProject_Add() options are explicitly prohibited (they +# are reserved for use by the download_project() command): +# +# CONFIGURE_COMMAND +# BUILD_COMMAND +# INSTALL_COMMAND +# TEST_COMMAND +# +# Only those ExternalProject_Add() arguments which relate to downloading, patching +# and updating of the project sources are intended to be used. Also note that at +# least one set of download-related arguments are required. +# +# If using CMake 3.2 or later, the UPDATE_DISCONNECTED option can be used to +# prevent a check at the remote end for changes every time CMake is run +# after the first successful download. See the documentation of the ExternalProject +# module for more information. It is likely you will want to use this option if it +# is available to you. Note, however, that the ExternalProject implementation contains +# bugs which result in incorrect handling of the UPDATE_DISCONNECTED option when +# using the URL download method or when specifying a SOURCE_DIR with no download +# method. Fixes for these have been created, the last of which is scheduled for +# inclusion in CMake 3.8.0. Details can be found here: +# +# https://gitlab.kitware.com/cmake/cmake/commit/bdca68388bd57f8302d3c1d83d691034b7ffa70c +# https://gitlab.kitware.com/cmake/cmake/issues/16428 +# +# If you experience build errors related to the update step, consider avoiding +# the use of UPDATE_DISCONNECTED. +# +# EXAMPLE USAGE: +# +# include(DownloadProject) +# download_project(PROJ googletest +# GIT_REPOSITORY /~https://github.com/google/googletest.git +# GIT_TAG master +# UPDATE_DISCONNECTED 1 +# QUIET +# ) +# +# add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR}) +# +#======================================================================================== + + +set(_DownloadProjectDir "${CMAKE_CURRENT_LIST_DIR}") + +include(CMakeParseArguments) + +function(download_project) + + set(options QUIET) + set(oneValueArgs + PROJ + PREFIX + DOWNLOAD_DIR + SOURCE_DIR + BINARY_DIR + # Prevent the following from being passed through + CONFIGURE_COMMAND + BUILD_COMMAND + INSTALL_COMMAND + TEST_COMMAND + ) + set(multiValueArgs "") + + cmake_parse_arguments(DL_ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + # Hide output if requested + if (DL_ARGS_QUIET) + set(OUTPUT_QUIET "OUTPUT_QUIET") + else() + unset(OUTPUT_QUIET) + message(STATUS "Downloading/updating ${DL_ARGS_PROJ}") + endif() + + # Set up where we will put our temporary CMakeLists.txt file and also + # the base point below which the default source and binary dirs will be + if (NOT DL_ARGS_PREFIX) + set(DL_ARGS_PREFIX "${CMAKE_BINARY_DIR}") + endif() + if (NOT DL_ARGS_DOWNLOAD_DIR) + set(DL_ARGS_DOWNLOAD_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-download") + endif() + + # Ensure the caller can know where to find the source and build directories + if (NOT DL_ARGS_SOURCE_DIR) + set(DL_ARGS_SOURCE_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-src") + endif() + if (NOT DL_ARGS_BINARY_DIR) + set(DL_ARGS_BINARY_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-build") + endif() + set(${DL_ARGS_PROJ}_SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" PARENT_SCOPE) + set(${DL_ARGS_PROJ}_BINARY_DIR "${DL_ARGS_BINARY_DIR}" PARENT_SCOPE) + + # The way that CLion manages multiple configurations, it causes a copy of + # the CMakeCache.txt to be copied across due to it not expecting there to + # be a project within a project. This causes the hard-coded paths in the + # cache to be copied and builds to fail. To mitigate this, we simply + # remove the cache if it exists before we configure the new project. It + # is safe to do so because it will be re-generated. Since this is only + # executed at the configure step, it should not cause additional builds or + # downloads. + file(REMOVE "${DL_ARGS_DOWNLOAD_DIR}/CMakeCache.txt") + + # Create and build a separate CMake project to carry out the download. + # If we've already previously done these steps, they will not cause + # anything to be updated, so extra rebuilds of the project won't occur. + # Make sure to pass through CMAKE_MAKE_PROGRAM in case the main project + # has this set to something not findable on the PATH. + configure_file("${_DownloadProjectDir}/DownloadProject.CMakeLists.cmake.in" + "${DL_ARGS_DOWNLOAD_DIR}/CMakeLists.txt") + execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" + -D "CMAKE_MAKE_PROGRAM:FILE=${CMAKE_MAKE_PROGRAM}" + . + RESULT_VARIABLE result + ${OUTPUT_QUIET} + WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}" + ) + if(result) + message(FATAL_ERROR "CMake step for ${DL_ARGS_PROJ} failed: ${result}") + endif() + execute_process(COMMAND ${CMAKE_COMMAND} --build . + RESULT_VARIABLE result + ${OUTPUT_QUIET} + WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}" + ) + if(result) + message(FATAL_ERROR "Build step for ${DL_ARGS_PROJ} failed: ${result}") + endif() + +endfunction() diff --git a/cmake/DoxygenDocumentation.cmake b/cmake/DoxygenDocumentation.cmake new file mode 100644 index 0000000..a7520c9 --- /dev/null +++ b/cmake/DoxygenDocumentation.cmake @@ -0,0 +1,163 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +# Define properties that we can place on documentation custom targets to +# propagate information necessary for dependency modeling and tagfile inclusion +define_property( + TARGET PROPERTY DOCUMENTATION_CROSSLINK_TAGFILE + BRIEF_DOCS "Doxygen documentation tagfile" + FULL_DOCS "Doxygen documentation tagfile for cross-linking separate documentations" +) + +define_property( + TARGET PROPERTY DOCUMENTATION_BINARY_DIR + BRIEF_DOCS "Doxygen documentation output directory" + FULL_DOCS "Doxygen documentation output directory" +) + +function(test_is_doc_target resultvar target) + set(${resultvar} FALSE PARENT_SCOPE) + if(TARGET ${target}) + get_property(crosslink_set + TARGET ${target} + PROPERTY DOCUMENTATION_CROSSLINK_TAGFILE SET + ) + set(${resultvar} ${crosslink_set} PARENT_SCOPE) + endif() +endfunction() + +function(scine_component_documentation) + # Call this after all dependencies have been included in the component's + # top-level directory CMakeLists.txt so that tagfiles are transitively + # included. Pass any documentation dependency target names as arguments. + + # Eliminate DOXYGEN_INPUT if present to avoid clash with FindDoxygen.cmake + if(NOT DOXYGEN_INPUT) + set(SCINE_DOXYGEN_INPUT + ${CMAKE_CURRENT_SOURCE_DIR}/src + ${CMAKE_CURRENT_SOURCE_DIR}/dev/cmake + ) + else() + set(SCINE_DOXYGEN_INPUT ${DOXYGEN_INPUT}) + unset(DOXYGEN_INPUT) + endif() + + # Find Doxygen and abort if not found + find_package(Doxygen QUIET) + if(NOT Doxygen_FOUND) + message(STATUS "Doxygen not found - Documentation for ${PROJECT_NAME} will not be built.") + return() + endif() + + # SCINE default Doxygen settings + if(NOT DOXYGEN_PROJECT_NAME) + set(DOXYGEN_PROJECT_NAME "Scine::${PROJECT_NAME}") + endif() + if(NOT DOXYGEN_PROJECT_DESCRIPTION) + set(DOXYGEN_PROJECT_DESCRIPTION "${PROJECT_DESCRIPTION}") + endif() + if(NOT DOXYGEN_FULL_PATH_NAMES) + set(DOXYGEN_FULL_PATH_NAMES YES) + endif() + if(NOT DOXYGEN_BUILTIN_STL_SUPPORT) + set(DOXYGEN_BUILTIN_STL_SUPPORT YES) + endif() + if(NOT DOXYGEN_DISTRIBUTE_GROUP_DOC) + set(DOXYGEN_DISTRIBUTE_GROUP_DOC YES) + endif() + if(NOT DOXYGEN_WARN_NO_PARAMDOC) + set(DOXYGEN_WARN_NO_PARAMDOC YES) + endif() + if(NOT DOXYGEN_WARN_LOGFILE) + set(DOXYGEN_WARN_LOGFILE "doxygen_warnings.txt") + endif() + if(NOT DOXYGEN_FILE_PATTERNS) + set(DOXYGEN_FILE_PATTERNS *.cpp *.hpp *.hxx *.h *.dox *.py) + endif() + if(NOT DOXYGEN_RECURSIVE) + set(DOXYGEN_RECURSIVE YES) + endif() + if(NOT DOXYGEN_GENERATE_TREEVIEW) + set(DOXYGEN_GENERATE_TREEVIEW YES) + endif() + if(NOT DOXYGEN_GENERATE_TODOLIST) + set(DOXYGEN_GENERATE_TODOLIST NO) + endif() + if(NOT DOXYGEN_GENERATE_TESTLIST) + set(DOXYGEN_GENERATE_TESTLIST NO) + endif() + if(NOT DOXYGEN_USE_MATHJAX) + set(DOXYGEN_USE_MATHJAX YES) + endif() + if(NOT DOXYGEN_GENERATE_LATEX) + set(DOXYGEN_GENERATE_LATEX NO) + endif() + if(NOT DOXYGEN_UML_LOOK) + set(DOXYGEN_UML_LOOK YES) + endif() + if(NOT DOXYGEN_TEMPLATE_RELATIONS) + set(DOXYGEN_TEMPLATE_RELATIONS YES) + endif() + if(NOT DOXYGEN_OUTPUT_DIRECTORY) + set(DOXYGEN_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") + endif() + if(NOT DOXYGEN_GENERATE_TAGFILE) + set(DOXYGEN_GENERATE_TAGFILE "${DOXYGEN_OUTPUT_DIRECTORY}/html/${PROJECT_NAME}.tag") + endif() + if(NOT DOXYGEN_QUIET) + set(DOXYGEN_QUIET YES) + endif() + + # Gather the full tree of documentation dependencies + set(GATHER_TARGETS ${ARGV}) + while(GATHER_TARGETS) + set(test_targets ${GATHER_TARGETS}) + set(GATHER_TARGETS "") + foreach(target ${test_targets}) + test_is_doc_target(is_doc_target ${target}) + if(is_doc_target) + list(APPEND UPSTREAM_TARGETS ${target}) + get_target_property(dependencies ${target} MANUALLY_ADDED_DEPENDENCIES) + foreach(dependency ${dependencies}) + list(APPEND GATHER_TARGETS ${dependency}) + endforeach() + endif() + endforeach() + list(REMOVE_DUPLICATES GATHER_TARGETS) + endwhile() + unset(GATHER_TARGETS) + if(UPSTREAM_TARGETS) + list(REMOVE_DUPLICATES UPSTREAM_TARGETS) + endif() + + # Model tagfile dependencies for cross-linking of documentations + if(NOT DOXYGEN_TAGFILES) + foreach(target ${UPSTREAM_TARGETS}) + get_target_property(tagfile ${target} DOCUMENTATION_CROSSLINK_TAGFILE) + get_target_property(output_dir ${target} DOCUMENTATION_BINARY_DIR) + file(RELATIVE_PATH upstream_output_dir_rel ${DOXYGEN_OUTPUT_DIRECTORY}/html ${output_dir}) + list(APPEND DOXYGEN_TAGFILES "${tagfile}=${upstream_output_dir_rel}") + endforeach() + endif() + + # Add the target + doxygen_add_docs(${PROJECT_NAME}Documentation ${SCINE_DOXYGEN_INPUT}) + set_target_properties(${PROJECT_NAME}Documentation PROPERTIES + DOCUMENTATION_CROSSLINK_TAGFILE ${DOXYGEN_GENERATE_TAGFILE} + DOCUMENTATION_BINARY_DIR ${DOXYGEN_OUTPUT_DIRECTORY}/html + ) + + # Enforce build order so upstream tagfiles are present + foreach(target ${UPSTREAM_TARGETS}) + add_dependencies(${PROJECT_NAME}Documentation ${target}) + endforeach() + + # Install the result of the target + #install( + # DIRECTORY ${DOXYGEN_OUTPUT_DIRECTORY} + # DESTINATION share/Scine/${PROJECT_NAME}/ + #) +endfunction() diff --git a/cmake/FindGMock.cmake b/cmake/FindGMock.cmake new file mode 100644 index 0000000..22a6fc5 --- /dev/null +++ b/cmake/FindGMock.cmake @@ -0,0 +1,48 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +# Try to find GMock +find_package(GTest QUIET) +find_package(PkgConfig QUIET) +pkg_check_modules(PC_GMOCK QUIET gmock) +set(GMOCK_DEFINITIONS ${PC_GMOCK_CFLAGS_OTHER}) + +find_path(GMOCK_INCLUDE_DIR gmock.h + HINTS ${GMOCK_ROOT}/include ${PC_GMOCK_INCLUDEDIR} ${PC_GMOCK_INCLUDE_DIRS} + PATH_SUFFIXES gmock) + +find_library(GMOCK_LIBRARY NAMES gmock libgmock + HINTS ${GMOCK_ROOT}/lib ${GMOCK_ROOT}/lib64 ${PC_GMOCK_LIBDIR} ${PC_GMOCK_LIBRARY_DIRS} ) + +find_library(GMOCK_MAIN_LIBRARY NAMES gmock_main libgmock_main + HINTS ${GMOCK_ROOT}/lib ${GMOCK_ROOT}/lib64 ${PC_GMOCK_LIBDIR} ${PC_GMOCK_LIBRARY_DIRS} ) + +include(FindPackageHandleStandardArgs) +# handle the QUIETLY and REQUIRED arguments and set GMOCK_FOUND to TRUE +# if all listed variables are TRUE +find_package_handle_standard_args(GMock DEFAULT_MSG + GMOCK_LIBRARY GMOCK_MAIN_LIBRARY GMOCK_INCLUDE_DIR GTEST_FOUND) + +mark_as_advanced(GMOCK_INCLUDE_DIR GMOCK_LIBRARY GMOCK_MAIN_LIBRARY) + +set(GMOCK_LIBRARIES ${GMOCK_LIBRARY} ) +set(GMOCK_INCLUDE_DIRS ${GMOCK_INCLUDE_DIR} ) +set(GMOCK_MAIN_LIBRARIES ${GMOCK_MAIN_LIBRARY} ) + +if (GMOCK_FOUND) + if (NOT TARGET gmock) + add_library(gmock IMPORTED STATIC GLOBAL) + set_property(TARGET gmock PROPERTY IMPORTED_LOCATION ${GMOCK_LIBRARY}) + set_property(TARGET gmock PROPERTY INTERFACE_INCLUDE_DIRECTORY ${GMOCK_INCLUDE_DIR}) + endif() + add_library(GMock::GMock ALIAS gmock) + if (NOT TARGET gmock_main) + add_library(gmock_main IMPORTED STATIC GLOBAL) + set_property(TARGET gmock_main PROPERTY IMPORTED_LOCATION ${GMOCK_MAIN_LIBRARY}) + set_property(TARGET gmock_main PROPERTY INTERFACE_LINK_LIBRARIES GMock::GMock GTest::GTest) + endif() + add_library(GMock::Main ALIAS gmock_main) +endif() diff --git a/cmake/FindMKL.cmake b/cmake/FindMKL.cmake new file mode 100644 index 0000000..6d213ed --- /dev/null +++ b/cmake/FindMKL.cmake @@ -0,0 +1,66 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +# Adapted from Serenity +include(FindPackageHandleStandardArgs) + +set(INTEL_ROOT "/opt/intel" CACHE PATH "Folder contains intel libs") +set(MKL_ROOT $ENV{MKLROOT} CACHE PATH "Folder contains MKL") + +set(MKL_FOUND TRUE) + +# Find include dir +find_path(MKL_INCLUDE_DIRS mkl.h + PATHS ${MKL_ROOT}/include) + +# Detect architecture +if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(SYSTEM_BIT "64") +elseif(CMAKE_SIZEOF_VOID_P EQUAL 4) + set(SYSTEM_BIT "32") +endif() + +# Set path according to architecture +if ("${SYSTEM_BIT}" STREQUAL "64") + set(MKL_LIB_ARCH lib/intel64/) +else() + set(MKL_LIB_ARCH lib/ia32/) +endif() + +# Find libraries +if ("${SYSTEM_BIT}" STREQUAL "64") + find_library(MKL_INTERFACE_LIBRARY libmkl_intel_lp64.so PATHS ${MKL_ROOT}/lib/intel64/) +else() + find_library(MKL_INTERFACE_LIBRARY libmkl_intel.so PATHS ${MKL_ROOT}/lib/ia32/) +endif() + +if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel") + find_library(MKL_THREADING_LIBRARY libmkl_intel_thread.so PATHS ${MKL_ROOT}/${MKL_LIB_ARCH}) +elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") + find_library(MKL_THREADING_LIBRARY libmkl_gnu_thread.so PATHS ${MKL_ROOT}/${MKL_LIB_ARCH}) +else() + unset(MKL_FOUND) +endif() + +find_library(MKL_CORE_LIBRARY libmkl_core.so PATHS ${MKL_ROOT}/${MKL_LIB_ARCH}) +find_library(MKL_AVX2_LIBRARY libmkl_avx2.so PATHS ${MKL_ROOT}/${MKL_LIB_ARCH}) +find_library(MKL_VML_AVX2_LIBRARY libmkl_vml_avx2.so PATHS ${MKL_ROOT}/${MKL_LIB_ARCH}) + +set(MKL_LIBRARIES ${MKL_AVX2_LIBRARY} ${MKL_VML_AVX2_LIBRARY} ${MKL_INTERFACE_LIBRARY} ${MKL_THREADING_LIBRARY} ${MKL_CORE_LIBRARY}) + +find_package_handle_standard_args(MKL DEFAULT_MSG MKL_INCLUDE_DIRS MKL_LIBRARIES) + +if(MKL_FOUND) + message("-- Found Intel MKL libraries:") + message("-- ${MKL_INCLUDE_DIRS} ") + message("-- ${MKL_AVX2_LIBRARY} ") + message("-- ${MKL_VML_AVX2_LIBRARY} ") + message("-- ${MKL_CORE_LIBRARY} ") + message("-- ${MKL_INTERFACE_LIBRARY} ") + message("-- ${MKL_THREADING_LIBRARY} ") +else() + set(MKL_LIBRARIES "MKL_LIBRARIES-NOTFOUND") +endif() diff --git a/cmake/FindPythonModule.cmake b/cmake/FindPythonModule.cmake new file mode 100644 index 0000000..9adcc86 --- /dev/null +++ b/cmake/FindPythonModule.cmake @@ -0,0 +1,31 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +include(FindPackageHandleStandardArgs) +# Find if a Python module is installed +# Found at http://www.cmake.org/pipermail/cmake/2011-January/041666.html +# To use do: find_python_module(PyQt4 REQUIRED) +function(find_python_module module) + string(TOUPPER ${module} module_upper) + if(NOT PY_${module_upper}) + if(ARGC GREATER 1 AND ARGV1 STREQUAL "REQUIRED") + set(${module}_FIND_REQUIRED TRUE) + endif() + # A module's location is usually a directory, but for binary modules + # it's a .so file. + execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c" + "import re, ${module}; print(re.compile('/__init__.py.*').sub('',${module}.__file__))" + RESULT_VARIABLE _${module}_status + OUTPUT_VARIABLE _${module}_location + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT _${module}_status) + set(PY_${module_upper} ${_${module}_location} CACHE STRING + "Location of Python module ${module}") + endif() + endif() + find_package_handle_standard_args(PY_${module} DEFAULT_MSG PY_${module_upper}) +endfunction() diff --git a/cmake/ImportCereal.cmake b/cmake/ImportCereal.cmake new file mode 100644 index 0000000..1c592a3 --- /dev/null +++ b/cmake/ImportCereal.cmake @@ -0,0 +1,38 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_cereal) + # If the target already exists, do nothing + if (NOT TARGET cereal::cereal) + # Try to find the package locally + find_package(cereal QUIET) + if(TARGET cereal) + message(STATUS "Cereal found locally at ${cereal_DIR}") + else() + # Download it instead + include(DownloadProject) + download_project(PROJ cereal + GIT_REPOSITORY https://gitlab.chab.ethz.ch/scine/cereal.git + GIT_TAG v1.2.2 + QUIET + UPDATE_DISCONNECTED 1 + ) + set(JUST_INSTALL_CEREAL ON CACHE BOOL "") # Prevent cereal from building tests + add_subdirectory(${cereal_SOURCE_DIR} ${cereal_BINARY_DIR}) + + # Final check if all went well + if(TARGET cereal) + message(STATUS "Cereal was not found in your PATH, so it was downloaded.") + else() + string(CONCAT error_msg + "Cereal was not found in your PATH and could not be established through " + "a download. Try specifying cereal_DIR or altering CMAKE_PREFIX_PATH to " + "point to a candidate cereal installation base directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportCore.cmake b/cmake/ImportCore.cmake new file mode 100644 index 0000000..4a7c5db --- /dev/null +++ b/cmake/ImportCore.cmake @@ -0,0 +1,42 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_core) + # If the target already exists, do nothing + if(NOT TARGET Scine::Core) + # Try to find the package locally + find_package(ScineCore QUIET) + if(TARGET Scine::Core) + message(STATUS "Scine::Core found locally at ${ScineCore_DIR}") + else() + # Download it instead + include(DownloadProject) + download_project( + PROJ scine-core + GIT_REPOSITORY /~https://github.com/qcscine/core.git + GIT_TAG 3.0.0 + QUIET + ) + # Note: Options defined in the project calling this function override default + # option values specified in the imported project. + add_subdirectory(${scine-core_SOURCE_DIR} ${scine-core_BINARY_DIR}) + + # Final check if all went well + if(TARGET Scine::Core) + message(STATUS + "Scine::Core was not found in your PATH, so it was downloaded." + ) + else() + string(CONCAT error_msg + "Scine::Core was not found in your PATH and could not be established " + "through a download. Try specifying Scine_DIR or altering " + "CMAKE_PREFIX_PATH to point to a candidate Scine installation base " + "directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportGTest.cmake b/cmake/ImportGTest.cmake new file mode 100644 index 0000000..933b56b --- /dev/null +++ b/cmake/ImportGTest.cmake @@ -0,0 +1,63 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_gtest) + # If the target already exists, do nothing + if((NOT TARGET GTest::GTest) OR (NOT TARGET GTest::Main) OR + (NOT TARGET GMock::GMock) OR (NOT TARGET GMock::Main)) + set(INSTALL_GTEST OFF CACHE BOOL "Disable Gtests install" FORCE) + # Try to find the package locally + set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}") + find_package(GTest 1.8.1 QUIET) + find_package(GMock 1.8.1 QUIET) + if((NOT TARGET GMock::GMock) OR (NOT TARGET GMock::Main)) + if((TARGET gmock) AND (TARGET gmock_main)) + add_library(GMock::GMock ALIAS gmock) + add_library(GMock::Main ALIAS gmock_main) + endif() + endif() + if((TARGET GTest::GTest) AND (TARGET GTest::Main) AND + (TARGET GMock::GMock) AND (TARGET GMock::Main)) + message(STATUS "Found GTest locally at: ${GTEST_LIBRARIES}") + else() + # Download it instead + message(STATUS "GTest and GMock were not found in your PATH, they are being downloaded.") + include(DownloadProject) + download_project( + PROJ googletest + GIT_REPOSITORY /~https://github.com/google/googletest.git + GIT_TAG release-1.10.0 + QUIET + UPDATE_DISCONNECTED 1 + ) + # Prevent GoogleTest from overriding our compiler/linker options when + # building with Visual Studio + set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) + + set(_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS}) + set(BUILD_SHARED_LIBS OFF) + add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR}) + set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS}) + unset(_BUILD_SHARED_LIBS) + add_library(GTest::GTest ALIAS gtest) + add_library(GTest::Main ALIAS gtest_main) + add_library(GMock::GMock ALIAS gmock) + add_library(GMock::Main ALIAS gmock_main) + + # Final check if all went well + if((TARGET GTest::GTest) AND (TARGET GTest::Main) AND + (TARGET GMock::GMock) AND (TARGET GMock::Main)) + message(STATUS "GTest and GMock sources were downloaded.") + else() + string(CONCAT error_msg + "GTest was not found in your PATH and could not be established through " + "a download. Try specifying GTest_DIR or altering CMAKE_PREFIX_PATH to " + "point to a candidate GTest installation base directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportIRC.cmake b/cmake/ImportIRC.cmake new file mode 100644 index 0000000..0348733 --- /dev/null +++ b/cmake/ImportIRC.cmake @@ -0,0 +1,83 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_irc) + # If the target already exists, do nothing + if(NOT TARGET irc) + find_package(irc QUIET) + if(NOT TARGET irc) + # Download it instead + include(DownloadProject) + download_project(PROJ irc + GIT_REPOSITORY /~https://github.com/rmeli/irc.git + GIT_TAG 1ad396a90d2978610e23e8b0801a15c4b68b13e8 + UPDATE_DISCONNECTED 1 + QUIET + ) + + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.13.0") + set(_CMP0077_DEFAULT ${CMAKE_POLICY_DEFAULT_CMP0077}) + set(CMAKE_POLICY_DEFAULT_CMP0077 NEW) + set(WITH_EIGEN TRUE) + set(BUILD_TESTS FALSE) + add_subdirectory(${irc_SOURCE_DIR} ${irc_BINARY_DIR}) + unset(WITH_EIGEN) + unset(BUILD_TESTS) + set(CMAKE_POLICY_DEFAULT_CMP0077 ${_CMP0077_DEFAULT}) + else() + # Before 3.13, we can't control options in irc's CMakeLists because + # CMP0077 is unknown. So we do this awkward dance of intrusive + # interface library generation. + add_library(irc INTERFACE) + target_include_directories(irc INTERFACE + $ + $/include> + ) + target_compile_definitions(irc INTERFACE + -DHAVE_EIGEN3 + -DEIGEN_MATRIX_PLUGIN="libirc/plugins/eigen/Matrix_initializer_list.h" + ) + # NOTE: we have not taken care of Boost and Eigen dependencies, and are + # assuming you are linking against these yourself. + install(DIRECTORY ${irc_SOURCE_DIR}/include/ DESTINATION include) + install(TARGETS irc EXPORT ircTargets) + include(CMakePackageConfigHelpers) + write_basic_package_version_file( + ${irc_BINARY_DIR}/irc-config-version.cmake + VERSION 0.1.0 + COMPATIBILITY AnyNewerVersion + ) + configure_package_config_file( + ${irc_SOURCE_DIR}/config.cmake.in + ${irc_BINARY_DIR}/irc-config.cmake + INSTALL_DESTINATION lib/cmake/irc + ) + # Targets files + install( + EXPORT ircTargets + FILE irc-targets.cmake + DESTINATION lib/cmake/irc + ) + install( + FILES + ${irc_BINARY_DIR}/irc-config.cmake + ${irc_BINARY_DIR}/irc-config-version.cmake + DESTINATION lib/cmake/irc + ) + endif() + + if(TARGET irc) + message(STATUS "IRC was not found in your PATH, so it was downloaded.") + else() + string(CONCAT error_msg + "IRC was not found in your PATH and could not be established through " + "a download. Try specifying irc_DIR or altering CMAKE_PREFIX_PATH to " + "point to a candidate irc installation base directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportMolassembler.cmake b/cmake/ImportMolassembler.cmake new file mode 100644 index 0000000..75d4f78 --- /dev/null +++ b/cmake/ImportMolassembler.cmake @@ -0,0 +1,43 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_molassembler) + # If the target already exists, do nothing + if(NOT TARGET Scine::Molassembler) + # Try to find the package locally + find_package(ScineMolassembler QUIET) + if(TARGET Scine::Molassembler) + message(STATUS "Scine::Molassembler found locally at ${ScineMolassembler_DIR}") + else() + # Download it instead + include(DownloadProject) + download_project( + PROJ molassembler + GIT_REPOSITORY /~https://github.com/qcscine/molassembler.git + GIT_TAG 1.0.0 + QUIET + UPDATE_DISCONNECTED 1 + ) + # Note: Options defined in the project calling this function override default + # option values specified in the imported project. + add_subdirectory(${molassembler_SOURCE_DIR} ${molassembler_BINARY_DIR}) + add_library(Scine::Molassembler ALIAS Molassembler) + # Final check if all went well + if(TARGET Scine::Molassembler) + message(STATUS + "Scine::Molassembler was not found in your PATH, so it was downloaded." + ) + else() + string(CONCAT error_msg + "Scine::Molassembler was not found in your PATH and could not be established " + "through a download. Try specifying molassembler_DIR or altering " + "CMAKE_PREFIX_PATH to point to a candidate molassembler installation base " + "directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportMongoCxx.cmake b/cmake/ImportMongoCxx.cmake new file mode 100644 index 0000000..20b0276 --- /dev/null +++ b/cmake/ImportMongoCxx.cmake @@ -0,0 +1,25 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_mongocxx) + # If the target already exists, do nothing + if (NOT TARGET MongoDBCXX) + find_package(libmongocxx QUIET) + if(DEFINED LIBMONGOCXX_INCLUDE_DIRS) + add_library(MongoDBCXX INTERFACE IMPORTED) + set_target_properties(MongoDBCXX PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${LIBMONGOCXX_INCLUDE_DIRS};${LIBBSONCXX_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${LIBMONGOCXX_LIBRARIES};${LIBBSONCXX_LIBRARIES}" + ) + else() + find_package(libmongocxx-static REQUIRED) + add_library(MongoDBCXX INTERFACE IMPORTED) + set_target_properties(MongoDBCXX PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${LIBMONGOCXX_STATIC_INCLUDE_DIRS};${LIBBSONCXX_STATIC_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${LIBMONGOCXX_STATIC_LIBRARIES};${LIBBSONCXX_STATIC_LIBRARIES}" + ) + endif() + endif() +endmacro() diff --git a/cmake/ImportPybind11.cmake b/cmake/ImportPybind11.cmake new file mode 100644 index 0000000..a2821a6 --- /dev/null +++ b/cmake/ImportPybind11.cmake @@ -0,0 +1,37 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_pybind11) + # If the target already exists, do nothing + if(NOT TARGET pybind11::pybind11) + find_package(pybind11 2.4.2 EXACT QUIET) + if(TARGET pybind11::pybind11) + message(STATUS "Found pybind11 at ${pybind11_DIR}") + else() + # Download it instead + include(DownloadProject) + download_project( + PROJ pybind11 + GIT_REPOSITORY /~https://github.com/pybind/pybind11.git + GIT_TAG v2.4.2 + QUIET + ) + + add_subdirectory(${pybind11_SOURCE_DIR} ${pybind11_BINARY_DIR}) + + # Final check if all went well + if(EXISTS "${pybind11_SOURCE_DIR}/CMakeLists.txt") + message(STATUS + "Pybind11 was not found in your PATH, so it was downloaded." + ) + else() + string(CONCAT error_msg + "Pybind11 was not be established through a download." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportSparrow.cmake b/cmake/ImportSparrow.cmake new file mode 100644 index 0000000..6e6ed0d --- /dev/null +++ b/cmake/ImportSparrow.cmake @@ -0,0 +1,44 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_sparrow) + # If the target already exists, do nothing + if(TARGET Scine::Sparrow) + message(STATUS "Scine::Sparrow present.") + else() + # Try to find the package locally + find_package(ScineSparrow QUIET) + if(TARGET Scine::Sparrow) + message(STATUS "Scine::Sparrow found locally at ${ScineSparrow_DIR}") + else() + # Download it instead + include(DownloadProject) + download_project( + PROJ scine-sparrow + GIT_REPOSITORY /~https://github.com/qcscine/sparrow.git + GIT_TAG 3.0.0 + QUIET + ) + # Note: Options defined in the project calling this function override default + # option values specified in the imported project. + add_subdirectory(${scine-sparrow_SOURCE_DIR} ${scine-sparrow_BINARY_DIR}) + + # Final check if all went well + if(TARGET Scine::Sparrow) + message(STATUS + "Scine::Sparrow was not found in your PATH, so it was downloaded." + ) + else() + string(CONCAT error_msg + "Scine::Sparrow was not found in your PATH and could not be established " + "through a download. Try specifying Scine_DIR or altering " + "CMAKE_PREFIX_PATH to point to a candidate Scine installation base " + "directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportUtilsOS.cmake b/cmake/ImportUtilsOS.cmake new file mode 100644 index 0000000..6f37047 --- /dev/null +++ b/cmake/ImportUtilsOS.cmake @@ -0,0 +1,42 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_utils_os) + # If the target already exists, do nothing + if(NOT TARGET Scine::UtilsOS) + # Try to find the package locally + find_package(ScineUtilsOS QUIET) + if(TARGET Scine::UtilsOS) + message(STATUS "Scine::UtilsOS found locally at ${ScineUtilsOS_DIR}") + else() + # Download it instead + include(DownloadProject) + download_project( + PROJ scine-utils-os + GIT_REPOSITORY /~https://github.com/qcscine/utils-open-source.git + GIT_TAG 3.0.0 + QUIET + ) + # Note: Options defined in the project calling this function override default + # option values specified in the imported project. + add_subdirectory(${scine-utils-os_SOURCE_DIR} ${scine-utils-os_BINARY_DIR}) + + # Final check if all went well + if(TARGET Scine::UtilsOS) + message(STATUS + "Scine::UtilsOS was not found in your PATH, so it was downloaded." + ) + else() + string(CONCAT error_msg + "Scine::UtilsOS was not found in your PATH and could not be established " + "through a download. Try specifying Scine_DIR or altering " + "CMAKE_PREFIX_PATH to point to a candidate Scine installation base " + "directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/ImportYamlCpp.cmake b/cmake/ImportYamlCpp.cmake new file mode 100644 index 0000000..f03a38f --- /dev/null +++ b/cmake/ImportYamlCpp.cmake @@ -0,0 +1,43 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +macro(import_yamlcpp) + # If the target already exists, do nothing + if (NOT TARGET yaml-cpp) + # If the target can be found, use it + find_package(yaml-cpp QUIET NO_CMAKE_PACKAGE_REGISTRY) + if (TARGET yaml-cpp) + message(STATUS "Found package yaml-cpp at ${yaml-cpp_DIR}") + else() + # Download it instead + include(DownloadProject) + set(YAML_CPP_BUILD_TESTS OFF CACHE BOOL "" FORCE) # Prevent yaml-cpp from building tests + + download_project(PROJ yamlcpp + GIT_REPOSITORY /~https://github.com/jbeder/yaml-cpp.git + GIT_TAG yaml-cpp-0.6.3 + QUIET + UPDATE_DISCONNECTED 1 + ) + add_subdirectory(${yamlcpp_SOURCE_DIR} ${yamlcpp_BINARY_DIR}) + + # Final check if all went well + if(TARGET yaml-cpp) + if(NOT YAML_BUILD_SHARED_LIBS) + # Static builds of yamlcpp need to be position-independent + set_target_properties(yaml-cpp PROPERTIES POSITION_INDEPENDENT_CODE ON) + endif() + message(STATUS "yaml-cpp was not found in your PATH, so it was downloaded.") + else() + string(CONCAT error_msg + "yaml-cpp was not found in your PATH and could not be established through " + "a download. Try specifying yaml-cpp_DIR or altering CMAKE_PREFIX_PATH to " + "point to a candidate yaml-cpp installation base directory." + ) + message(FATAL_ERROR ${error_msg}) + endif() + endif() + endif() +endmacro() diff --git a/cmake/Licenses.cmake b/cmake/Licenses.cmake new file mode 100644 index 0000000..d839820 --- /dev/null +++ b/cmake/Licenses.cmake @@ -0,0 +1,54 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +cmake_minimum_required(VERSION 3.9) +set(BOOST_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/boost.txt") +set(CEREAL_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/cereal.txt") +set(EIGEN_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/eigen.txt") +set(GTEST_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/gtest.txt") +set(LIBIRC_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/libirc.txt") +set(MONGOCXX_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/mongocxx.txt") +set(PYBIND_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/pybind.txt") +set(XTB_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/xtb.txt") +set(YAMLCPP_LICENSE_FILE "${CMAKE_CURRENT_LIST_DIR}/licenses/yamlcpp.txt") + +set(_DEPENDENCIES BOOST CEREAL EIGEN GTEST LIBIRC MONGOCXX PYBIND YAMLCPP) +foreach(DEPNAME ${_DEPENDENCIES}) + list(APPEND ALL_LICENSE_FILES ${${DEPNAME}_LICENSE_FILE}) +endforeach() + +# Writes a list of external license files depending on what targets exist +# Call **after** your find_package calls +macro (get_license_files) + set(EXTERNAL_LICENSE_FILES "") + if(TARGET Boost::boost) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${BOOST_LICENSE_FILE}) + endif() + if(TARGET cereal::cereal) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${CEREAL_LICENSE_FILE}) + endif() + if(TARGET Eigen3::Eigen) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${EIGEN_LICENSE_FILE}) + endif() + if(TARGET gtest) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${GTEST_LICENSE_FILE}) + endif() + if(DEFINED ${LIBIRC_INCLUDE_DIR}) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${LIBIRC_LICENSE_FILE}) + endif() + if(TARGET MongoDBCXX) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${MONGOCXX_LICENSE_FILE}) + endif() + if(TARGET pybind11) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${PYBIND_LICENSE_FILE}) + endif() + if(TARGET xtb_static) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${XTB_LICENSE_FILE}) + endif() + if(TARGET yaml-cpp) + set(EXTERNAL_LICENSE_FILES "${EXTERNAL_LICENSE_FILES}" ${YAMLCPP_LICENSE_FILE}) + endif() +endmacro() diff --git a/cmake/README.rst b/cmake/README.rst new file mode 100644 index 0000000..7aa204e --- /dev/null +++ b/cmake/README.rst @@ -0,0 +1,9 @@ +========================= +SCINE: Common CMake Files +========================= + +This folder stores the common CMake files used in all other SCINE projects. + +The main guidelines on these CMake files and also the CMake based build +architecture of SCINE can be found in the developers documentation which is +also hosted centrally at https://scine.ethz.ch/documentation. diff --git a/cmake/SphinxDocumentation.cmake b/cmake/SphinxDocumentation.cmake new file mode 100644 index 0000000..2dbc1e2 --- /dev/null +++ b/cmake/SphinxDocumentation.cmake @@ -0,0 +1,164 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +define_property( + TARGET PROPERTY SPHINX_OUTPUT_DIR + BRIEF_DOCS "Sphinx output directory" + FULL_DOCS "Sphinx documentation output directory" +) + +function(test_is_sphinx_documentation resultvar target) + set(${resultvar} FALSE PARENT_SCOPE) + if(TARGET ${target}) + get_property(has_sphinx_output_dir + TARGET ${target} + PROPERTY SPHINX_OUTPUT_DIR SET + ) + set(${resultvar} ${has_sphinx_output_dir} PARENT_SCOPE) + endif() +endfunction() + +function(gather_upstream_sphinxes) + include(CMakeBackports) + list_pop_front(ARGV resultvar) + + set(GATHER_TARGETS ${ARGV}) + while(GATHER_TARGETS) + set(test_targets ${GATHER_TARGETS}) + set(GATHER_TARGETS "") + foreach(target ${test_targets}) + test_is_sphinx_documentation(is_sphinx_doc ${target}) + if(is_sphinx_doc) + list(APPEND UPSTREAM_TARGETS ${target}) + get_target_property(dependencies ${target} MANUALLY_ADDED_DEPENDENCIES) + foreach(dependency ${dependencies}) + list(APPEND GATHER_TARGETS ${dependency}) + endforeach() + endif() + endforeach() + list(REMOVE_DUPLICATES GATHER_TARGETS) + endwhile() + unset(GATHER_TARGETS) + if(UPSTREAM_TARGETS) + list(REMOVE_DUPLICATES UPSTREAM_TARGETS) + endif() + + set(${resultvar} ${UPSTREAM_TARGETS} PARENT_SCOPE) +endfunction() + +# Usage: +# scine_sphinx_documentation( +# TARGET +# CONFIGURATION +# OUTPUT +# LINK +# SOURCE_DIR +# [DOCTEST] [DOCTEST_REQUIRES ] +# ) +function(scine_sphinx_documentation) + set(options DOCTEST) + set(oneValueArgs TARGET CONFIGURATION OUTPUT) + set(multiValueArgs LINK SOURCE_DIR DOCTEST_REQUIRES) + cmake_parse_arguments(SPHINX + "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} + ) + + if(NOT SCINE_BUILD_DOCS) + return() + endif() + + include(FindPythonModule) + find_python_module(sphinx QUIET) + if(NOT PY_SPHINX) + message(STATUS "Sphinx python package not found, cannot build python documentation") + return() + endif() + + # Copy sources + file(GLOB SPHINX_SOURCES ${SPHINX_SOURCE_DIR}/*) + file(COPY ${SPHINX_SOURCES} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/sphinx) + gather_upstream_sphinxes(SPHINX_UPSTREAM_LINKS ${SPHINX_LINK}) + + foreach(target ${SPHINX_UPSTREAM_LINKS}) + get_target_property(DOC_NAME ${target} NAME) + get_target_property(DOC_OUTPUT_DIR ${target} SPHINX_OUTPUT_DIR) + file(RELATIVE_PATH REL_PATH ${CMAKE_CURRENT_BINARY_DIR}/sphinx ${DOC_OUTPUT_DIR}) + list(APPEND INTERSPHINX_MAPPINGS "\"${DOC_NAME}\": (\"${REL_PATH}\", None)") + message(STATUS "${DOC_NAME}: ${REL_PATH}") + endforeach() + if(INTERSPHINX_MAPPINGS) + list(JOIN INTERSPHINX_MAPPINGS ", " INTERSPHINX_MAPPING) + else() + set(INTERSPHINX_MAPPING "") + endif() + + # Configure configuration file + configure_file( + ${SPHINX_CONFIGURATION} + ${CMAKE_CURRENT_BINARY_DIR}/sphinx/conf.py + @ONLY + ) + + if(TARGET ${SPHINX_TARGET}) + # Assume it's a python binding module and an upstream dependency of the + # documentation + get_target_property(PYTHON_MODULE_NAME ${SPHINX_TARGET} NAME) + else() + # Only use the specified argument as part of the target name instead + set(PYTHON_MODULE_NAME ${SPHINX_TARGET}) + endif() + + add_custom_target(${PYTHON_MODULE_NAME}Documentation + ALL + COMMAND ${PYTHON_EXECUTABLE} -m sphinx -b html -a -E "sphinx" "${SPHINX_OUTPUT}" + DEPENDS ${SPHINX_SOURCES} + COMMENT "Generate python documentation with sphinx for ${PYTHON_MODULE_NAME}" + ) + if(TARGET ${SPHINX_TARGET}) + add_dependencies(${PYTHON_MODULE_NAME}Documentation ${SPHINX_TARGET}) + endif() + set_target_properties(${PYTHON_MODULE_NAME}Documentation PROPERTIES + SPHINX_OUTPUT_DIR "${SPHINX_OUTPUT}" + ) + + foreach(target ${SPHINX_UPSTREAM_LINKS}) + add_dependencies(${PYTHON_MODULE_NAME}Documentation ${target}) + endforeach() + + if(SPHINX_DOCTEST AND SCINE_BUILD_TESTS) + find_python_module(doctest QUIET) + if(NOT PY_DOCTEST) + message(WARNING "Python doctesting of ${PYTHON_MODULE_NAME} disabled: doctest module is missing") + return() + endif() + + foreach(dependency ${SPHINX_DOCTEST_REQUIRES}) + if(TARGET ${dependency}) + get_target_property(MODULE_BINARY_DIR ${dependency} BINARY_DIR) + list(APPEND PYTHONPATH_EXTS ${MODULE_BINARY_DIR}) + else() + find_python_module(${target} QUIET) + if(NOT PY_${dependency}) + message(WARNING "Python doctesting of ${PYTHON_MODULE_NAME} disabled: ${dependency} module is missing") + return() + endif() + endif() + endforeach() + + add_test( + NAME ${PYTHON_MODULE_NAME}Doctest + COMMAND ${PYTHON_EXECUTABLE} -c "import sys, doctest, ${PYTHON_MODULE_NAME}; (f, _) = doctest.testmod(${PYTHON_MODULE_NAME}); sys.exit(f > 0)" + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ) + + if(PYTHONPATH_EXTS) + list(JOIN PYTHONPATH_EXTS ":" PYTHONPATH_EXT) + set_tests_properties(${PYTHON_MODULE_NAME}Doctest PROPERTIES + ENVIRONMENT PYTHONPATH=${PYTHONPATH_EXT}:$ENV{PYTHONPATH} + ) + endif() + endif() +endfunction() diff --git a/cmake/TargetLibName.cmake b/cmake/TargetLibName.cmake new file mode 100644 index 0000000..7a195fa --- /dev/null +++ b/cmake/TargetLibName.cmake @@ -0,0 +1,73 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +# Figure out the name of a imported target's filename or the filename of an +# in-tree library target +macro(target_lib_filename target output) + if(NOT TARGET ${target}) + message(FATAL_ERROR "target_lib_filename passed target that does not exist") + endif() + + get_target_property(_imported ${target} IMPORTED) + if(_imported) + foreach(BUILD_TYPE Debug;Release;MinSizeRel;RelWithDebInfo) + string(TOUPPER "${BUILD_TYPE}" _upper_build_type) + get_target_property(_name_attempt ${target} IMPORTED_SONAME_${_upper_build_type}) + if(_name_attempt) + set(${output} ${_name_attempt}) + break() + endif() + endforeach() + unset(_name_attempt) + unset(_upper_build_type) + + if(NOT DEFINED ${output}) + message(FATAL_ERROR "Could not determine library filename from IMPORTED_SONAME_XXX") + endif() + else() + get_target_property(_output_name ${target} OUTPUT_NAME) + get_target_property(_type ${target} TYPE) + if(${_type} STREQUAL "SHARED_LIBRARY") + set(${output} "${CMAKE_SHARED_LIBRARY_PREFIX}${_output_name}${CMAKE_SHARED_LIBRARY_SUFFIX}") + elseif(${_type} STREQUAL "STATIC_LIBRARY") + set(${output} "${CMAKE_STATIC_LIBRARY_PREFIX}${_output_name}${CMAKE_STATIC_LIBRARY_SUFFIX}") + else() + message(FATAL_ERROR "Could not determine library filename of in-tree target") + endif() + unset(_output_name) + unset(_type) + endif() + unset(_imported) +endmacro() + +# Figure out the directory where an imported target is and where a target +# built in-tree will be +macro(target_lib_directory target output) + if(NOT TARGET ${target}) + message(FATAL_ERROR "target_lib_directory passed target that does not exist") + endif() + + get_target_property(_imported ${target} IMPORTED) + if(_imported) + foreach(BUILD_TYPE Debug;Release;MinSizeRel;RelWithDebInfo) + string(TOUPPER "${BUILD_TYPE}" _upper_build_type) + get_target_property(_name_attempt ${target} IMPORTED_LOCATION_${_upper_build_type}) + if(_name_attempt) + get_filename_component(${output} ${_name_attempt} DIRECTORY) + break() + endif() + endforeach() + unset(_name_attempt) + unset(_upper_build_type) + + if(NOT DEFINED ${output}) + message(FATAL_ERROR "Could not determine library directory from IMPORTED_LOCATION_XXX") + endif() + else() + get_target_property(${output} ${target} BINARY_DIR) + endif() + unset(_imported) +endmacro() diff --git a/cmake/Utils.cmake b/cmake/Utils.cmake new file mode 100644 index 0000000..e460c7f --- /dev/null +++ b/cmake/Utils.cmake @@ -0,0 +1,84 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# +function(scine_install_component_cmake_files) + set(options "") + set(oneValueArgs COMPONENT EXPORT_NAME CONFIG_FILE) + set(multiValueArgs "") + cmake_parse_arguments(SCINE_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + include(CMakePackageConfigHelpers) + + # -- Config version file + write_basic_package_version_file( + "${CMAKE_CURRENT_BINARY_DIR}/${SCINE_INSTALL_COMPONENT}/${SCINE_INSTALL_COMPONENT}ConfigVersion.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion + ) + + set(SCINE_COMPONENT ${PROJECT_NAME}) + set(SCINE_COMPONENT_VERSION ${PROJECT_VERSION}) + + # -- Config file + configure_package_config_file( + "${CMAKE_CURRENT_SOURCE_DIR}/config.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/${SCINE_INSTALL_COMPONENT}/${SCINE_INSTALL_COMPONENT}Config.cmake" + INSTALL_DESTINATION "${SCINE_CMAKE_PACKAGE_ROOT}/${SCINE_INSTALL_COMPONENT}" + PATH_VARS SCINE_CMAKE_PACKAGE_ROOT + ) + + # Install config and configVersion + install( + FILES + "${CMAKE_CURRENT_BINARY_DIR}/${SCINE_INSTALL_COMPONENT}/${SCINE_INSTALL_COMPONENT}Config.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/${SCINE_INSTALL_COMPONENT}/${SCINE_INSTALL_COMPONENT}ConfigVersion.cmake" + DESTINATION "${SCINE_CMAKE_PACKAGE_ROOT}/${SCINE_INSTALL_COMPONENT}" + COMPONENT ${SCINE_INSTALL_COMPONENT} + ) + + # -- Targets file + # This makes the project importable from the build directory + export( + EXPORT ${SCINE_INSTALL_EXPORT_NAME} + FILE "${CMAKE_CURRENT_BINARY_DIR}/${SCINE_INSTALL_COMPONENT}/${SCINE_INSTALL_COMPONENT}Targets.cmake" + NAMESPACE Scine:: + ) + + # This makes the project importable from the install directory + # Put config file in per-project dir (name MUST match), can also + # just go into /cmake. + install( + EXPORT ${SCINE_INSTALL_EXPORT_NAME} + FILE "${SCINE_INSTALL_COMPONENT}Targets.cmake" + DESTINATION "${SCINE_CMAKE_PACKAGE_ROOT}/${SCINE_INSTALL_COMPONENT}" + NAMESPACE Scine:: + COMPONENT ${SCINE_INSTALL_COMPONENT} + ) +endfunction() + +function(workaround_link_object_library_target targetName) + set(options "") + set(oneValueArgs "") + set(multiValueArgs PUBLIC PRIVATE) + cmake_parse_arguments(WORKAROUND_LINK "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) + + if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.12.0") + target_link_libraries(targetName + PUBLIC ${WORKAROUND_LINK_PUBLIC} + PRIVATE ${WORKAROUND_LINK_PRIVATE} + ) + else() + foreach(publicTarget ${WORKAROUND_LINK_PUBLIC}) + target_include_directories(targetName + PUBLIC $ + ) + endforeach() + foreach(privateTarget ${WORKAROUND_LINK_PRIVATE}) + target_include_directories(targetName + PRIVATE $ + ) + endforeach() + endif() +endfunction() diff --git a/cmake/cmake.dox b/cmake/cmake.dox new file mode 100644 index 0000000..2761879 --- /dev/null +++ b/cmake/cmake.dox @@ -0,0 +1,113 @@ +/*! +@page cmake CMake Functions +@tableofcontents +Custom CMake functions used throughout Scine component build trees. + +@section scine_setup_component +@verbatim +scine_setup_component() +@endverbatim + +Entry point for setting up a CMake tree that provides a Scine `COMPONENT`. + +- Sets C++ standard +- Adds cross-project options (e.g. SCINE_BUILD_TESTS) +- If testing is enabled, imports google test +- Adds the master configuration file to installed CMake package files +- Enables documentation with Doxygen (see `scine_component_documentation`) +- Includes the Scine CMake utilities + +@section scine_component_documentation +@verbatim +scine_component_documentation() +@endverbatim + +Generates a `Doxyfile` from all `DOXYGEN_XYZ` variables currently set and adds +a target Documentation that builds the documentation. You can +modify the generated Doxyfile and thus the generated documentation by changing +any Doxygen option through the CMake `DOXYGEN_` prefix. If unset, it +initializes the following settings: + +@verbatim +- DOXYGEN_FULL_PATH_NAMES = YES +- DOXYGEN_FULL_PATH_NAMES = YES +- DOXYGEN_BUILTIN_STL_SUPPORT = YES +- DOXYGEN_DISTRIBUTE_GROUP_DOC = YES +- DOXYGEN_WARN_NO_PARAMDOC = YES +- DOXYGEN_WARN_LOGFILE = "doxygen_warnings.txt" +- DOXYGEN_FILE_PATTERNS = *.cpp *.hpp *.hxx *.h *.dox *.py *.cmake +- DOXYGEN_RECURSIVE = YES +- DOXYGEN_GENERATE_TREEVIEW = YES +- DOXYGEN_USE_MATHJAX = YES +- DOXYGEN_GENERATE_LATEX = NO +- DOXYGEN_UML_LOOK = YES +- DOXYGEN_TEMPLATE_RELATIONS = YES +- DOXYGEN_PROJECT_NAME = "Scine::${PROJECT_NAME}" +- DOXYGEN_PROJECT_DESCRIPTION = "${PROJECT_DESCRIPTION}" +- DOXYGEN_INPUT = ${CMAKE_CURRENT_SOURCE_DIR}/src + ${CMAKE_CURRENT_SOURCE_DIR}/dev/cmake +@endverbatim + +If the documentation is built, it is also installed to +`/share/Scine//html`. + + +@section import_gtest +@verbatim +import_gtest() +@endverbatim + +Imports googletest. Tries to find it locally first, but if it is not found, +downloads it from our gitlab mirror. Googletest is then installed along. + +@section scine_import +@verbatim +scine_import(COMPONENT componentName GIT_REPOSITORY gitRepository + [GIT_TAG gitTag]) +@endverbatim + +Tries to find a Scine `COMPONENT` in the `PATH`. If the `COMPONENT` is not +found, it is instead downloaded from `gitRepository` with the optional +`gitTag` and built and installed along. + +@b Postcondition Scine:: is a valid target + + +@section scine_install_component_cmake_files +@verbatim +scine_install_component_cmake_files(COMPONENT componentName + EXPORT_NAME exportName) +@endverbatim + +Handles the creation and installation of CMake package files to +`SCINE_CMAKE_PACKAGE_ROOT`. + +@b Preconditions: +- In the current source dir, there is a file named `config.cmake.in` +- `EXPORT_NAME` references a group of exported targets generated via + `install(TARGETS ... EXPORT exportName)`. + +This function generates `ConfigVersion.cmake` using +project-level version information (which you automatically provide if you have +called `scine_setup_component` or have supplied a `project` call with `VERSION` +information). It configures `config.cmake.in` to a +`Config.cmake`. Lastly, it generates a +`Targets.cmake` from the targets in `exportName` with the +appropriate Scine namespace. All of the generated files are added to the list +of installed files. + +@section workaround_link_object_library_target +@verbatim +workaround_link_object_library_target(targetName [PUBLIC ...] [PRIVATE ...]) +@endverbatim + +Prior to CMake version 3.12, you cannot link libraries to an object library +target and populate the properties necessary to compile it transitively from +its linked targets (see https://gitlab.kitware.com/cmake/cmake/issues/14778). +This function exists to provide similar functionality to lower CMake versions. + +If CMake 3.12 or greater, calls `target_link_libraries` as normal. +If lower than 3.12, calls `target_include_directories` with all +`INTERFACE_INCLUDE_DIRECTORIES` defined by the targets listed in `PUBLIC` and +`PRIVATE`. +*/ diff --git a/cmake/licenses/boost.txt b/cmake/licenses/boost.txt new file mode 100644 index 0000000..36b7cd9 --- /dev/null +++ b/cmake/licenses/boost.txt @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/cmake/licenses/cereal.txt b/cmake/licenses/cereal.txt new file mode 100644 index 0000000..acc4fd8 --- /dev/null +++ b/cmake/licenses/cereal.txt @@ -0,0 +1,24 @@ +Copyright (c) 2014, Randolph Voorhies, Shane Grant +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of cereal nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/cmake/licenses/eigen.txt b/cmake/licenses/eigen.txt new file mode 100644 index 0000000..14e2f77 --- /dev/null +++ b/cmake/licenses/eigen.txt @@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/cmake/licenses/gtest.txt b/cmake/licenses/gtest.txt new file mode 100644 index 0000000..1941a11 --- /dev/null +++ b/cmake/licenses/gtest.txt @@ -0,0 +1,28 @@ +Copyright 2008, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/cmake/licenses/libirc.txt b/cmake/licenses/libirc.txt new file mode 100644 index 0000000..0514b6d --- /dev/null +++ b/cmake/licenses/libirc.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017-2019 Rocco Meli, Peter Bygrave + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/cmake/licenses/mongocxx.txt b/cmake/licenses/mongocxx.txt new file mode 100644 index 0000000..e06d208 --- /dev/null +++ b/cmake/licenses/mongocxx.txt @@ -0,0 +1,202 @@ +Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/cmake/licenses/pybind.txt b/cmake/licenses/pybind.txt new file mode 100644 index 0000000..6f15578 --- /dev/null +++ b/cmake/licenses/pybind.txt @@ -0,0 +1,29 @@ +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Please also refer to the file CONTRIBUTING.md, which clarifies licensing of +external contributions to this project including patches, pull requests, etc. diff --git a/cmake/licenses/xtb.txt b/cmake/licenses/xtb.txt new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/cmake/licenses/xtb.txt @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/cmake/licenses/yamlcpp.txt b/cmake/licenses/yamlcpp.txt new file mode 100644 index 0000000..991fdbb --- /dev/null +++ b/cmake/licenses/yamlcpp.txt @@ -0,0 +1,19 @@ +Copyright (c) 2008-2015 Jesse Beder. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/conan/__init__.py b/conan/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/conan/__init__.py @@ -0,0 +1 @@ + diff --git a/conan/base.py b/conan/base.py new file mode 100644 index 0000000..a9ff2a9 --- /dev/null +++ b/conan/base.py @@ -0,0 +1,222 @@ +__copyright__ = """This code is licensed under the 3-clause BSD license. +Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +See LICENSE.txt for details +""" + +import os +import sys +from .utils import microarch, python_module_dir +from conans import ConanFile, CMake, tools +from conans.errors import ConanInvalidConfiguration + + +class ScineConan(ConanFile): + """ Object to inherit from to implement a ConanFile. + + When inheriting from this base class, you need to make + a _configure_cmake method, which can usually be implemented + in terms of _configure_cmake_base. + """ + + license = "BSD-3-Clause" + author = "Research Group Prof. Markus Reiher, LPC, ETH Zurich" + url = "/~https://github.com/qcscine" + topics = ("chemistry", "cheminformatics") + settings = "os", "compiler", "build_type", "arch" + generators = "cmake" + revision_mode = "scm" + keep_imports = True + + _cmake = None + + def _conan_hook_path(self): + """ Path of the exported cmake hook file """ + return os.path.join("dev", "conan", "hook.cmake") + + def _exports_suffix(self, suffix): + """ Whether any exported file ends with a particular suffix """ + return any(fname.endswith(suffix) for fname in self.exports_sources) + + def _propagate_scine_option(self, option): + """ Propagates options to SCINE dependencies. + + Assumes SCINE dependencies will also have the option as it + unfortunately can't be checked. + + """ + option_value = self.options.get_safe(option) + + if option_value is None: + return + + # You might want to check if the dependency has this option, but you + # can't. The fields aren't populated with default values nor validated + # until the point where they are propagated. + # + # Try self.output.info("{}".format(self.options[dep].fields)) -> [] + if hasattr(self, "requires"): + for dep in self.requires: + if dep.startswith("scine_"): + setattr(self.options[dep], option, option_value) + + if hasattr(self, "build_requires"): + for dep in self.build_requires: + if dep.startswith("scine_"): + setattr(self.options[dep], option, option_value) + + def configure(self): + """ Determine whether the settings and options are correct """ + if self._exports_suffix(".cpp"): + tools.check_min_cppstd(self, "14") + + if self.options.get_safe("coverage"): + if not self.options.get_safe("tests"): + raise ConanInvalidConfiguration( + "Coverage requires testing to be enabled") + + if self.settings.get_safe("build_type") != "Debug": + raise ConanInvalidConfiguration( + "Coverage testing should be done on a debug build") + + # See the assumptions on this fn + self._propagate_scine_option("python") + + if self.options.get_safe("microarch") == "none": + self._propagate_scine_option("microarch") + + def _default_cmake_definitions(self, project_name): + """ Builds the default SCINE CMake definitions """ + definitions = { + "SCINE_BUILD_DOCS": False, + "SCINE_MARCH": "", + "PYTHON_EXECUTABLE": sys.executable + } + + project_include_key = "CMAKE_PROJECT_" + project_name + "_INCLUDE" + definitions[project_include_key] = self._conan_hook_path() + + if self.options.get_safe("microarch") == "detect": + definitions["SCINE_MARCH"] = microarch(self) or "" + + if "tests" in self.options: + definitions["SCINE_BUILD_TESTS"] = self.options.tests + + if "python" in self.options: + definitions["SCINE_BUILD_PYTHON_BINDINGS"] = self.options.python + + if "coverage" in self.options: + definitions["COVERAGE"] = self.options.coverage + + if "docs" in self.options: + definitions["SCINE_BUILD_DOCS"] = self.options.docs + + return definitions + + def _configure_cmake_base(self, project_name, definitions=None): + """ Base fn to implement _configure_cmake with for derived classes + + Requires you to specify the CMake project name, i.e. the first + argument to the first `project` call in the top-level + CMakeLists.txt. + + >>> # Example for UtilsOS + >>> class Foo(ScineConan): + ... def _configure_cmake(self): + ... return super()._configure_cmake_base("UtilsOS") + """ + + # CMake instance is class state to avoid running configure twice + if self._cmake: + return self._cmake + + self._cmake = CMake(self) + default_definitions = self._default_cmake_definitions(project_name) + self._cmake.definitions.update(default_definitions) + if definitions is not None: + self._cmake.definitions.update(definitions) + + self._cmake.configure() + return self._cmake + + def build(self): + """ Builds the project and runs tests if enabled """ + cmake = self._configure_cmake() + cmake.build() + + if self.options.get_safe("tests"): + # Many of our tests are parallel. If the tests are run in parallel, + # then the individual tests are run serially, seriously affecting + # wall clock times. + cmake.parallel = False + cmake.test(output_on_failure=True) + cmake.parallel = True + + def imports(self): + """ Copies license files from all dependencies """ + self.copy("license*", dst="licenses", folder=True, ignore_case=True) + self.copy("copying*", dst="licenses", folder=True, ignore_case=True) + self.copy("copyright*", dst="licenses", folder=True, ignore_case=True) + + def package(self): + """ Post-build, create desired package file structure """ + cmake = self._configure_cmake() + cmake.install() + cmake.patch_config_paths() + # Copy dependencies' licenses and our own + self.copy("licenses/*") + self.copy("LICENSE.txt") + + def build_requirements(self): + """ Determine additional requirements needed only to build """ + if self.options.get_safe("python"): + self.build_requires("pybind11/2.4.2@scine/stable") + + if self.options.get_safe("tests"): + self.build_requires("gtest/1.10.0") + + # CMake 3.13.4 is the minimum required for modern Boost releases + if not tools.which("cmake") or CMake.get_version() < "3.13.4": + self.build_requires("cmake/[>=3.13.4]@scine/stable") + + def package_id(self): + """ Defines package ABI by modifying a hashable info object """ + # Remove options that do not contribute to package ID + for name in ["tests", "coverage", "docs"]: + if name in self.options: + delattr(self.info.options, name) + + # Overwrite microarch value in info with detected or make it empty + if "microarch" in self.options: + if self.options.get_safe("microarch") == "detect": + self.info.options.microarch = microarch(self) or "" + else: + self.info.options.microarch = "" + + def package_info(self): + """ Defines properties of the package for downstream """ + # Collect static and shared libraries in the package + self.cpp_info.libs = tools.collect_libs(self) + + # Add binaries to PATH + binpath = os.path.join(self.package_folder, "bin") + if os.path.exists(binpath): + self.env_info.PATH.append(binpath) + + # Add shared libraries to os appropriate environment variable + libpath = os.path.join(self.package_folder, "lib") + if self.options.get_safe("shared") and os.path.exists(libpath): + if self.settings.os == "Windows": + self.env_info.PATH.append(libpath) + elif self.settings.os == "Linux": + self.env_info.LD_LIBRARY_PATH.append(libpath) + elif self.settings.os == "Macos": + self.env_info.DYLD_LIBRARY_PATH.append(libpath) + + # Add python packages to PYTHONPATH + if self.options.get_safe("python"): + try: + pypath = python_module_dir(self.package_folder) + self.env_info.PYTHONPATH.append(pypath) + except RuntimeError: + warning_str = "Expected python site-packages folder does not exist" + self.output.warn(warning_str) diff --git a/conan/hook.cmake b/conan/hook.cmake new file mode 100644 index 0000000..efdc5a4 --- /dev/null +++ b/conan/hook.cmake @@ -0,0 +1,11 @@ +# +# This file is licensed under the 3-clause BSD license. +# Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +# See LICENSE.txt for details. +# + +include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) +conan_set_find_paths() +conan_set_find_library_paths() +conan_set_libcxx() +conan_check_compiler() diff --git a/conan/utils.py b/conan/utils.py new file mode 100644 index 0000000..1434914 --- /dev/null +++ b/conan/utils.py @@ -0,0 +1,62 @@ +__copyright__ = """This code is licensed under the 3-clause BSD license. +Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group. +See LICENSE.txt for details +""" + +import os +import sys +import re +import subprocess as sp + + +def microarch(conanfile): + """ Determine microarch of compiler and os (CPU chipset family or ISA) """ + cmdlist = None + regex = None + + # Note that it doesn't matter if gcc or clang have different names for what + # we call microarchitecture here. Any package ID is a hash convolution of + # os, compiler, and then the microarch string. Collisions are so unlikely + # they're impossible. + + if conanfile.settings.compiler == "gcc": + cmdlist = ["gcc", "-march=native", "-Q", "--help=target"] + regex = r"-march=\s+(?P[A-z0-9]+)" + + if conanfile.settings.compiler in ["clang", "apple-clang"]: + cmdlist = ["clang", "-march=native", "-xc", "-", "-###"] + regex = r"\"-target-cpu\"\\s+\"(?P[A-z0-9]+)\"" + + if cmdlist is None: + return None + + result = sp.run(cmdlist, stdout=sp.PIPE, + stderr=sp.STDOUT, universal_newlines=True) + result.check_returncode() + matcher = re.compile(regex) + + for match in matcher.finditer(result.stdout): + return match.group("arch") + + for match in matcher.finditer(result.stderr): + return match.group("arch") + + return None + + +def python_module_dir(pkg_folder): + """ Returns the assumed path for a pip installed python package + + Using setuptools and pip to install to a site-packages folder will + give a path that includes the interpreter major-minor version. We + infer that path here dynamically. + """ + python_dir = "python" + str(sys.version_info.major) + \ + "." + str(sys.version_info.minor) + lib_dirs = ["lib", "lib64"] + for lib in lib_dirs: + folder = os.path.join(pkg_folder, lib, python_dir, "site-packages") + if os.path.exists(folder): + return folder + + raise RuntimeError("Python module folder not found!")