Enable C++ Modules

.editorconfig

@@ -6,7 +6,7 @@ root = true
 charset = utf-8
 end_of_line = lf
 insert_final_newline = true
-trim_trailing_whitespace = true
+trim_trailing_whitespace = false
 indent_style = space
 indent_size = 2
 

CMakeLists.txt

@@ -138,6 +138,7 @@ option(website   "Enable website generation (make website<-live>)." OFF)
 option(valgrind  "Enable valgrind tests and make build compatible with valgrind tool." ON)
 option(rpath     "Link libraries with built-in RPATH (run-time search path)." OFF)
 option(real_t    "Define data type for real numbers. Currently supported: float, double" double)
+option(runtime_cxxmodules "Enable C++ Modules support." ON)
 
 if(APPLE)
   # ParaView on Apple devices
@@ -504,6 +505,7 @@ file(COPY ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/launcher.sh
         GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
 
 # -------------------- includes -----------------------------------------------
+include(RootMacros)
 include(BioDynaMo)
 include(ExternalProject)
 include(Documentation)

cmake/BioDynaMo.cmake

@@ -108,17 +108,33 @@ function(build_shared_library TARGET)
   # We always need dictionaries for the plugins (plugin manager requires class
   # information)
   if(dict OR DEFINED ARG_PLUGIN)
-    # generate dictionary using genreflex
+    # generate dictionary using rootcling reflex
     set(DICT_FILE "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET}_dict")
     set(BDM_DICT_FILE "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET}_bdm_dict.cc")
+    set(ROOT_HEADERS)
+    string(REPLACE "${CMAKE_SOURCE_DIR}/src/" "" ROOT_HEADERS_TEMP "${ARG_HEADERS}")
+    string(REPLACE "${CMAKE_SOURCE_DIR}/test/" "" ROOT_HEADERS "${ROOT_HEADERS_TEMP}")
+
+
+    if (runtime_cxxmodules)
+      set(MODULEMAP "--moduleMapFile=${CMAKE_BINARY_DIR}/include/module.modulemap")
+    else()
+      set(NO_MODULE "NO_CXXMODULE")
+    endif()
+
+    if (NOT ${TARGET} STREQUAL "biodynamo")
+      #set(DEPENDENCY_OPTION "-m ${CMAKE_CURRENT_BINARY_DIR}/lib/biodynamo.pcm")
+      #set(NO_MODULE "NO_CXXMODULE")
+      #set(MODULEMAP)
+    endif()
 
     # Since the location of the CMake files differ in the build and installation
     # directory, we check if BDM_CMAKE_DIR is already set (in build directory
     # case). Otherwise, set it to the installation directory
     if(NOT DEFINED BDM_CMAKE_DIR)
       set(BDM_CMAKE_DIR $ENV{BDMSYS}/share/cmake)
     endif()
-    REFLEX_GENERATE_DICTIONARY(${DICT_FILE} ${ARG_HEADERS} SELECTION ${BDM_CMAKE_DIR}/${ARG_SELECTION})
+    ROOT_GENERATE_DICTIONARY(${DICT_FILE} ${ROOT_HEADERS} MODULE ${TARGET} LINKDEF ${BDM_CMAKE_DIR}/${ARG_SELECTION} REFLEX ${NO_MODULE} OPTIONS ${DEPENDENCY_OPTION} -I src --inlineInputHeader --noIncludePaths ${MODULEMAP})
     if (BDM_OUT_OF_SOURCE)
       set(BDM_DICT_BIN_PATH "$ENV{BDMSYS}/bin")
     else()
@@ -130,8 +146,11 @@ function(build_shared_library TARGET)
     else()
       set(BDM_OUT_OF_SRC_ARG --bdm-source ${CMAKE_SOURCE_DIR})
     endif()
+    if (BDM_CXXMODULES)
+      set(BDM_CXX_MODULES_ARG "--cxxmodules")
+    endif()
     add_custom_command(OUTPUT "${BDM_DICT_FILE}"
-                       COMMAND ${Python_EXECUTABLE} ${BDM_DICT_BIN_PATH}/bdm-dictionary ${BDM_OUT_OF_SRC_ARG} --output ${BDM_DICT_FILE} --include-dirs ${INCLUDE_DIRS} --headers ${ARG_HEADERS}
+      COMMAND ${Python_EXECUTABLE} ${BDM_DICT_BIN_PATH}/bdm-dictionary ${BDM_OUT_OF_SRC_ARG} ${BDM_CXX_MODULES_ARG} --output ${BDM_DICT_FILE} --include-dirs ${INCLUDE_DIRS} --headers ${ARG_HEADERS}
                        DEPENDS ${ARG_HEADERS} ${BDM_DICT_BIN_PATH}/bdm-dictionary)
     # generate shared library
     add_library(${TARGET} SHARED ${ARG_SOURCES} ${DICT_FILE}.cc ${BDM_DICT_FILE})
@@ -140,9 +159,9 @@ function(build_shared_library TARGET)
     endif()
     target_link_libraries(${TARGET} ${ARG_LIBRARIES})
     if (DEFINED CMAKE_INSTALL_LIBDIR)
-      add_custom_command(TARGET ${TARGET}
-            POST_BUILD
-            COMMAND ${CMAKE_COMMAND} -E copy ${DICT_FILE}_rdict.pcm ${CMAKE_INSTALL_LIBDIR})
+      # add_custom_command(TARGET ${TARGET}
+      #      POST_BUILD
+      #     COMMAND ${CMAKE_COMMAND} -E copy ${DICT_FILE}_rdict.pcm ${CMAKE_INSTALL_LIBDIR})
     endif()
   else()
     add_library(${TARGET} SHARED ${ARG_SOURCES})

cmake/FindROOT.cmake

@@ -97,108 +97,10 @@ mark_as_advanced(ROOT_CONFIG_EXECUTABLE)
 include(CMakeParseArguments)
 find_program(ROOTCLING_EXECUTABLE rootcling
   HINTS "$ENV{ROOTSYS}/bin" "$ENV{BDM_ROOT_DIR}/bin" "${CMAKE_THIRD_PARTY_DIR}/root/bin")
-find_program(GENREFLEX_EXECUTABLE genreflex
-  HINTS "$ENV{ROOTSYS}/bin" "$ENV{BDM_ROOT_DIR}/bin" "${CMAKE_THIRD_PARTY_DIR}/root/bin")
 #find_package(GCCXML)
 
 # We use the launcher script to emulate a `source thisbdm.sh` call
 if(NOT BDM_OUT_OF_SOURCE)
   set(LAUNCHER ${CMAKE_BINARY_DIR}/launcher.sh)
 endif()
 
-#----------------------------------------------------------------------------
-# function ROOT_GENERATE_DICTIONARY( dictionary
-#                                    header1 header2 ...
-#                                    LINKDEF linkdef1 ...
-#                                    OPTIONS opt1...)
-function(ROOT_GENERATE_DICTIONARY dictionary)
-  CMAKE_PARSE_ARGUMENTS(ARG "" "" "LINKDEF;OPTIONS" "" ${ARGN})
-  #---Get the list of include directories------------------
-  get_directory_property(incdirs INCLUDE_DIRECTORIES)
-  set(includedirs)
-  foreach( d ${incdirs})
-     set(includedirs ${includedirs} -I${d})
-  endforeach()
-  #---Get the list of header files-------------------------
-  set(headerfiles)
-  foreach(fp ${ARG_UNPARSED_ARGUMENTS})
-    if(${fp} MATCHES "[*?]") # Is this header a globbing expression?
-      file(GLOB files ${fp})
-      foreach(f ${files})
-        if(NOT f MATCHES LinkDef) # skip LinkDefs from globbing result
-          set(headerfiles ${headerfiles} ${f})
-        endif()
-      endforeach()
-    else()
-      find_file(headerFile ${fp} HINTS ${incdirs})
-      set(headerfiles ${headerfiles} ${headerFile})
-      unset(headerFile CACHE)
-    endif()
-  endforeach()
-  #---Get LinkDef.h file------------------------------------
-  set(linkdefs)
-  foreach( f ${ARG_LINKDEF})
-    find_file(linkFile ${f} HINTS ${incdirs})
-    set(linkdefs ${linkdefs} ${linkFile})
-    unset(linkFile CACHE)
-  endforeach()
-  #---call rootcling------------------------------------------
-  add_custom_command(OUTPUT ${dictionary}.cxx
-                     OUTPUT ${dictionary}_rdict.pcm
-                     COMMAND ${LAUNCHER} ${ROOTCLING_EXECUTABLE} -f ${dictionary}.cxx
-                                         ${ARG_OPTIONS} ${includedirs} ${headerfiles} ${linkdefs}
-                     DEPENDS ${headerfiles} ${linkdefs} VERBATIM)
-endfunction()
-
-#----------------------------------------------------------------------------
-# function REFLEX_GENERATE_DICTIONARY(dictionary
-#                                     header1 header2 ...
-#                                     SELECTION selectionfile ...
-#                                     OPTIONS opt1...)
-function(REFLEX_GENERATE_DICTIONARY dictionary)
-  CMAKE_PARSE_ARGUMENTS(ARG "" "" "SELECTION;OPTIONS" "" ${ARGN})
-  #---Get the list of header files-------------------------
-  set(headerfiles)
-  foreach(fp ${ARG_UNPARSED_ARGUMENTS})
-    file(GLOB files ${fp})
-    if(files)
-      foreach(f ${files})
-        set(headerfiles ${headerfiles} ${f})
-      endforeach()
-    else()
-      set(headerfiles ${headerfiles} ${fp})
-    endif()
-  endforeach()
-  #---Get Selection file------------------------------------
-  if(IS_ABSOLUTE ${ARG_SELECTION})
-    set(selectionfile ${ARG_SELECTION})
-  else()
-    set(selectionfile ${CMAKE_CURRENT_SOURCE_DIR}/${ARG_SELECTION})
-  endif()
-  #---Get the list of include directories------------------
-  get_directory_property(incdirs INCLUDE_DIRECTORIES)
-  set(includedirs)
-  foreach( d ${incdirs})
-    set(includedirs ${includedirs} -I${d})
-  endforeach()
-  #---Get preprocessor definitions--------------------------
-  get_directory_property(defs COMPILE_DEFINITIONS)
-  foreach( d ${defs})
-   set(definitions ${definitions} -D${d})
-  endforeach()
-  #---Nanes and others---------------------------------------
-  set(gensrcdict ${dictionary}.cc)
-  if(MSVC)
-    set(gccxmlopts "--gccxmlopt=\"--gccxml-compiler cl\"")
-  else()
-    #set(gccxmlopts "--gccxmlopt=\'--gccxml-cxxflags -m64 \'")
-    set(gccxmlopts)
-  endif()
-  #set(rootmapname ${dictionary}Dict.rootmap)
-  #set(rootmapopts --rootmap=${rootmapname} --rootmap-lib=${libprefix}${dictionary}Dict)
-  #---Actual command----------------------------------------
-  add_custom_command(OUTPUT ${gensrcdict} ${rootmapname} ${dictionary}_rdict.pcm
-                     COMMAND ${LAUNCHER} ${GENREFLEX_EXECUTABLE} ${headerfiles} -o ${gensrcdict} ${rootmapopts} --select=${selectionfile} --noIncludePaths
-                            ${ARG_OPTIONS} ${includedirs} ${definitions}
-                     DEPENDS ${headerfiles} ${selectionfile})
-endfunction()