always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cmake: rework .Net support

Browse Source
This commit is contained in:
Mizux Seiha
2021-12-02 23:35:58 +01:00
committed by Corentin Le Molgat
parent 976f227b67
commit 72ebd8b748
10 changed files with 98 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
cmake/dotnet.cmake
View File

@@ -105,7 +105,14 @@ else()
message(FATAL_ERROR "Unsupported system !")
endif()
set(DOTNET_NATIVE_PROJECT ${DOTNET_PACKAGE}.runtime.${RUNTIME_IDENTIFIER})
message(STATUS ".Net runtime project: ${DOTNET_NATIVE_PROJECT}")
set(DOTNET_NATIVE_PROJECT_DIR ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_NATIVE_PROJECT})
message(STATUS ".Net runtime project build path: ${DOTNET_NATIVE_PROJECT_DIR}")
set(DOTNET_PROJECT ${DOTNET_PACKAGE})
message(STATUS ".Net project: ${DOTNET_PROJECT}")
set(DOTNET_PROJECT_DIR ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_PROJECT})
message(STATUS ".Net project build path: ${DOTNET_PROJECT_DIR}")
# Swig wrap all libraries
foreach(SUBPROJECT IN ITEMS algorithms graph init linear_solver constraint_solver sat util)
@@ -131,7 +138,7 @@ if(DEFINED ENV{DOTNET_SNK})
)
else()
set(DOTNET_SNK_PROJECT CreateSigningKey)
set(DOTNET_SNK_PROJECT_PATH ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_SNK_PROJECT})
set(DOTNET_SNK_PROJECT_DIR ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_SNK_PROJECT})
add_custom_command(
OUTPUT ${PROJECT_BINARY_DIR}/dotnet/or-tools.snk
COMMAND ${CMAKE_COMMAND} -E copy_directory
@@ -141,103 +148,92 @@ else()
--project ${DOTNET_SNK_PROJECT}/${DOTNET_SNK_PROJECT}.csproj
/or-tools.snk
BYPRODUCTS
${DOTNET_SNK_PROJECT_PATH}/bin
${DOTNET_SNK_PROJECT_PATH}/obj
${DOTNET_SNK_PROJECT_DIR}/bin
${DOTNET_SNK_PROJECT_DIR}/obj
COMMENT "Generate or-tools.snk using CreateSigningKey project"
WORKING_DIRECTORY dotnet
VERBATIM
)
endif()
file(MAKE_DIRECTORY ${DOTNET_PACKAGES_DIR})
############################
## .Net Runtime Package ##
############################
message(STATUS ".Net runtime project: ${DOTNET_NATIVE_PROJECT}")
set(DOTNET_NATIVE_PROJECT_PATH ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_NATIVE_PROJECT})
message(STATUS ".Net runtime project build path: ${DOTNET_NATIVE_PROJECT_PATH}")
file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/dotnet/packages)
# *.csproj.in contains:
# CMake variable(s) (@PROJECT_NAME@) that configure_file() can manage and
# generator expression ($<TARGET_FILE:...>) that file(GENERATE) can manage.
configure_file(
${PROJECT_SOURCE_DIR}/ortools/dotnet/${DOTNET_PACKAGE}.runtime.csproj.in
${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj.in
${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj.in
@ONLY)
file(GENERATE
OUTPUT ${DOTNET_NATIVE_PROJECT_PATH}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
INPUT ${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj.in)
OUTPUT ${DOTNET_NATIVE_PROJECT_DIR}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
INPUT ${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj.in)
add_custom_command(
OUTPUT ${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj
DEPENDS ${DOTNET_NATIVE_PROJECT_PATH}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
OUTPUT ${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj
DEPENDS ${DOTNET_NATIVE_PROJECT_DIR}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
COMMAND ${CMAKE_COMMAND} -E copy ./$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in ${DOTNET_NATIVE_PROJECT}.csproj
WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_PATH}
WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_DIR}
)
add_custom_command(
OUTPUT ${DOTNET_NATIVE_PROJECT_PATH}/timestamp
OUTPUT ${DOTNET_NATIVE_PROJECT_DIR}/timestamp
COMMAND ${DOTNET_EXECUTABLE} build -c Release /p:Platform=x64 ${DOTNET_NATIVE_PROJECT}.csproj
COMMAND ${DOTNET_EXECUTABLE} pack -c Release ${DOTNET_NATIVE_PROJECT}.csproj
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_NATIVE_PROJECT_PATH}/timestamp
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_NATIVE_PROJECT_DIR}/timestamp
DEPENDS
${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj
${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj
${PROJECT_BINARY_DIR}/dotnet/or-tools.snk
Dotnet${PROJECT_NAME}_proto
google-ortools-native
BYPRODUCTS
${DOTNET_NATIVE_PROJECT_PATH}/bin
${DOTNET_NATIVE_PROJECT_PATH}/obj
COMMENT "Generate .Net native package ${DOTNET_NATIVE_PROJECT} (${DOTNET_NATIVE_PROJECT_PATH}/timestamp)"
WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_PATH}
${DOTNET_NATIVE_PROJECT_DIR}/bin
${DOTNET_NATIVE_PROJECT_DIR}/obj
COMMENT "Generate .Net native package ${DOTNET_NATIVE_PROJECT} (${DOTNET_NATIVE_PROJECT_DIR}/timestamp)"
WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_DIR}
)
add_custom_target(dotnet_native_package
DEPENDS
${DOTNET_NATIVE_PROJECT_PATH}/timestamp
${DOTNET_NATIVE_PROJECT_DIR}/timestamp
WORKING_DIRECTORY dotnet)
####################
## .Net Package ##
####################
message(STATUS ".Net project: ${DOTNET_PROJECT}")
set(DOTNET_PROJECT_PATH ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_PROJECT})
message(STATUS ".Net project build path: ${DOTNET_PROJECT_PATH}")
set(PROJECT_DOTNET_DIR ${PROJECT_BINARY_DIR}/dotnet)
configure_file(
${PROJECT_SOURCE_DIR}/ortools/dotnet/${DOTNET_PROJECT}.csproj.in
${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj.in
${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj.in
@ONLY)
add_custom_command(
OUTPUT ${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj
DEPENDS ${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj.in
OUTPUT ${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj
DEPENDS ${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj.in
COMMAND ${CMAKE_COMMAND} -E copy ${DOTNET_PROJECT}.csproj.in ${DOTNET_PROJECT}.csproj
WORKING_DIRECTORY ${DOTNET_PROJECT_PATH}
WORKING_DIRECTORY ${DOTNET_PROJECT_DIR}
)
add_custom_command(
OUTPUT ${DOTNET_PROJECT_PATH}/timestamp
OUTPUT ${DOTNET_PROJECT_DIR}/timestamp
COMMAND ${DOTNET_EXECUTABLE} build -c Release /p:Platform=x64 ${DOTNET_PROJECT}.csproj
COMMAND ${DOTNET_EXECUTABLE} pack -c Release ${DOTNET_PROJECT}.csproj
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_PROJECT_PATH}/timestamp
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_PROJECT_DIR}/timestamp
DEPENDS
${PROJECT_BINARY_DIR}/dotnet/or-tools.snk
${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj
${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj
dotnet_native_package
BYPRODUCTS
dotnet/${DOTNET_PROJECT}/bin
dotnet/${DOTNET_PROJECT}/obj
COMMENT "Generate .Net package ${DOTNET_PROJECT} (${DOTNET_PROJECT_PATH}/timestamp)"
WORKING_DIRECTORY ${DOTNET_PROJECT_PATH}
COMMENT "Generate .Net package ${DOTNET_PROJECT} (${DOTNET_PROJECT_DIR}/timestamp)"
WORKING_DIRECTORY ${DOTNET_PROJECT_DIR}
)
add_custom_target(dotnet_package ALL
DEPENDS
${DOTNET_PROJECT_PATH}/timestamp
${DOTNET_PROJECT_DIR}/timestamp
WORKING_DIRECTORY dotnet)
#################
@@ -255,47 +251,46 @@ function(add_dotnet_test FILE_NAME)
get_filename_component(COMPONENT_DIR ${FILE_NAME} DIRECTORY)
get_filename_component(COMPONENT_NAME ${COMPONENT_DIR} NAME)
set(DOTNET_TEST_PATH ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${TEST_NAME})
message(STATUS "build path: ${DOTNET_TEST_PATH}")
file(MAKE_DIRECTORY ${DOTNET_TEST_PATH})
set(DOTNET_TEST_DIR ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${TEST_NAME})
message(STATUS "build path: ${DOTNET_TEST_DIR}")
file(MAKE_DIRECTORY ${DOTNET_TEST_DIR})
add_custom_command(
OUTPUT ${DOTNET_TEST_PATH}/${TEST_NAME}.cs
COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_TEST_PATH}/
OUTPUT ${DOTNET_TEST_DIR}/${TEST_NAME}.cs
COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_TEST_DIR}/
MAIN_DEPENDENCY ${FILE_NAME}
VERBATIM
)
set(DOTNET_PACKAGES_DIR "${PROJECT_BINARY_DIR}/dotnet/packages")
configure_file(
${PROJECT_SOURCE_DIR}/ortools/dotnet/Test.csproj.in
${DOTNET_TEST_PATH}/${TEST_NAME}.csproj
${DOTNET_TEST_DIR}/${TEST_NAME}.csproj
@ONLY)
add_custom_command(
OUTPUT ${DOTNET_TEST_PATH}/timestamp
OUTPUT ${DOTNET_TEST_DIR}/timestamp
COMMAND ${DOTNET_EXECUTABLE} build -c Release
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_TEST_PATH}/timestamp
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_TEST_DIR}/timestamp
DEPENDS
${DOTNET_TEST_PATH}/${TEST_NAME}.csproj
${DOTNET_TEST_PATH}/${TEST_NAME}.cs
${DOTNET_TEST_DIR}/${TEST_NAME}.csproj
${DOTNET_TEST_DIR}/${TEST_NAME}.cs
dotnet_package
BYPRODUCTS
${DOTNET_TEST_PATH}/bin
${DOTNET_TEST_PATH}/obj
COMMENT "Compiling .Net ${COMPONENT_NAME}/${TEST_NAME}.cs (${DOTNET_TEST_PATH}/timestamp)"
WORKING_DIRECTORY ${DOTNET_TEST_PATH})
${DOTNET_TEST_DIR}/bin
${DOTNET_TEST_DIR}/obj
COMMENT "Compiling .Net ${COMPONENT_NAME}/${TEST_NAME}.cs (${DOTNET_TEST_DIR}/timestamp)"
WORKING_DIRECTORY ${DOTNET_TEST_DIR})
add_custom_target(dotnet_${COMPONENT_NAME}_${TEST_NAME} ALL
DEPENDS
${DOTNET_TEST_PATH}/timestamp
${DOTNET_TEST_DIR}/timestamp
WORKING_DIRECTORY dotnet)
if(BUILD_TESTING)
add_test(
NAME dotnet_${COMPONENT_NAME}_${TEST_NAME}
COMMAND ${DOTNET_EXECUTABLE} test --no-build -c Release
WORKING_DIRECTORY ${DOTNET_TEST_PATH})
WORKING_DIRECTORY ${DOTNET_TEST_DIR})
endif()
message(STATUS "Configuring test ${FILE_NAME} done")
endfunction()
@@ -316,48 +311,47 @@ function(add_dotnet_sample FILE_NAME)
get_filename_component(COMPONENT_DIR ${SAMPLE_DIR} DIRECTORY)
get_filename_component(COMPONENT_NAME ${COMPONENT_DIR} NAME)
set(DOTNET_SAMPLE_PATH ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${SAMPLE_NAME})
message(STATUS "build path: ${DOTNET_SAMPLE_PATH}")
file(MAKE_DIRECTORY ${DOTNET_SAMPLE_PATH})
set(DOTNET_SAMPLE_DIR ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${SAMPLE_NAME})
message(STATUS "build path: ${DOTNET_SAMPLE_DIR}")
file(MAKE_DIRECTORY ${DOTNET_SAMPLE_DIR})
add_custom_command(
OUTPUT ${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.cs
COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_SAMPLE_PATH}/
OUTPUT ${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.cs
COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_SAMPLE_DIR}/
MAIN_DEPENDENCY ${FILE_NAME}
VERBATIM
)
set(DOTNET_PACKAGES_DIR "${PROJECT_BINARY_DIR}/dotnet/packages")
configure_file(
${PROJECT_SOURCE_DIR}/ortools/dotnet/Sample.csproj.in
${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.csproj
${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.csproj
@ONLY)
add_custom_command(
OUTPUT ${DOTNET_SAMPLE_PATH}/timestamp
OUTPUT ${DOTNET_SAMPLE_DIR}/timestamp
COMMAND ${DOTNET_EXECUTABLE} build -c Release
COMMAND ${DOTNET_EXECUTABLE} pack -c Release
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_SAMPLE_PATH}/timestamp
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_SAMPLE_DIR}/timestamp
DEPENDS
${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.csproj
${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.cs
${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.csproj
${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.cs
dotnet_package
BYPRODUCTS
${DOTNET_SAMPLE_PATH}/bin
${DOTNET_SAMPLE_PATH}/obj
COMMENT "Compiling .Net ${COMPONENT_NAME}/${SAMPLE_NAME}.cs (${DOTNET_SAMPLE_PATH}/timestamp)"
WORKING_DIRECTORY ${DOTNET_SAMPLE_PATH})
${DOTNET_SAMPLE_DIR}/bin
${DOTNET_SAMPLE_DIR}/obj
COMMENT "Compiling .Net ${COMPONENT_NAME}/${SAMPLE_NAME}.cs (${DOTNET_SAMPLE_DIR}/timestamp)"
WORKING_DIRECTORY ${DOTNET_SAMPLE_DIR})
add_custom_target(dotnet_${COMPONENT_NAME}_${SAMPLE_NAME} ALL
DEPENDS
${DOTNET_SAMPLE_PATH}/timestamp
${DOTNET_SAMPLE_DIR}/timestamp
WORKING_DIRECTORY dotnet)
if(BUILD_TESTING)
add_test(
NAME dotnet_${COMPONENT_NAME}_${SAMPLE_NAME}
COMMAND ${DOTNET_EXECUTABLE} run --no-build -c Release
WORKING_DIRECTORY ${DOTNET_SAMPLE_PATH})
WORKING_DIRECTORY ${DOTNET_SAMPLE_DIR})
endif()
message(STATUS "Configuring sample ${FILE_NAME} done")
endfunction()
@@ -377,49 +371,48 @@ function(add_dotnet_example FILE_NAME)
get_filename_component(COMPONENT_DIR ${FILE_NAME} DIRECTORY)
get_filename_component(COMPONENT_NAME ${COMPONENT_DIR} NAME)
set(DOTNET_EXAMPLE_PATH ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${EXAMPLE_NAME})
message(STATUS "build path: ${DOTNET_EXAMPLE_PATH}")
file(MAKE_DIRECTORY ${DOTNET_EXAMPLE_PATH})
set(DOTNET_EXAMPLE_DIR ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${EXAMPLE_NAME})
message(STATUS "build path: ${DOTNET_EXAMPLE_DIR}")
file(MAKE_DIRECTORY ${DOTNET_EXAMPLE_DIR})
add_custom_command(
OUTPUT ${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.cs
COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_EXAMPLE_PATH}/
OUTPUT ${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.cs
COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_EXAMPLE_DIR}/
MAIN_DEPENDENCY ${FILE_NAME}
VERBATIM
)
set(DOTNET_PACKAGES_DIR "${PROJECT_BINARY_DIR}/dotnet/packages")
set(SAMPLE_NAME ${EXAMPLE_NAME})
configure_file(
${PROJECT_SOURCE_DIR}/ortools/dotnet/Sample.csproj.in
${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.csproj
${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.csproj
@ONLY)
add_custom_command(
OUTPUT ${DOTNET_EXAMPLE_PATH}/timestamp
OUTPUT ${DOTNET_EXAMPLE_DIR}/timestamp
COMMAND ${DOTNET_EXECUTABLE} build -c Release
COMMAND ${DOTNET_EXECUTABLE} pack -c Release
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_EXAMPLE_PATH}/timestamp
COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_EXAMPLE_DIR}/timestamp
DEPENDS
${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.csproj
${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.cs
${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.csproj
${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.cs
dotnet_package
BYPRODUCTS
${DOTNET_EXAMPLE_PATH}/bin
${DOTNET_EXAMPLE_PATH}/obj
COMMENT "Compiling .Net ${COMPONENT_NAME}/${EXAMPLE_NAME}.cs (${DOTNET_EXAMPLE_PATH}/timestamp)"
WORKING_DIRECTORY ${DOTNET_EXAMPLE_PATH})
${DOTNET_EXAMPLE_DIR}/bin
${DOTNET_EXAMPLE_DIR}/obj
COMMENT "Compiling .Net ${COMPONENT_NAME}/${EXAMPLE_NAME}.cs (${DOTNET_EXAMPLE_DIR}/timestamp)"
WORKING_DIRECTORY ${DOTNET_EXAMPLE_DIR})
add_custom_target(dotnet_${COMPONENT_NAME}_${EXAMPLE_NAME} ALL
DEPENDS
${DOTNET_EXAMPLE_PATH}/timestamp
${DOTNET_EXAMPLE_DIR}/timestamp
WORKING_DIRECTORY dotnet)
if(BUILD_TESTING)
add_test(
NAME dotnet_${COMPONENT_NAME}_${EXAMPLE_NAME}
COMMAND ${DOTNET_EXECUTABLE} run --no-build -c Release
WORKING_DIRECTORY ${DOTNET_EXAMPLE_PATH})
WORKING_DIRECTORY ${DOTNET_EXAMPLE_DIR})
endif()
message(STATUS "Configuring example ${FILE_NAME} done")
endfunction()

2
makefiles/Makefile.dotnet.mk
View File

@@ -434,7 +434,7 @@ $(TEMP_DOTNET_DIR)/$(DOTNET_ORTOOLS_ASSEMBLY_NAME)/$(DOTNET_ORTOOLS_ASSEMBLY_NAM
$(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
$(SED) -i -e 's/@DOTNET_PACKAGES_DIR@/..\/packages/' \
$(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
$(SED) -i -e 's/@PROJECT_DOTNET_DIR@/..\/..\/ortools\/gen/' \
$(SED) -i -e 's/@DOTNET_PROJECT_DIR@/..\/..\/ortools\/gen/' \
$(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
$(SED) -i -e 's/@PROJECT_SOURCE_DIR@/..\/../' \
$(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj

2
ortools/algorithms/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE knapsack_solver.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_algorithms
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/algorithms
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/${PROJECT_NAME}/algorithms
SOURCES knapsack_solver.i)
#target_include_directories(dotnet_algorithms PRIVATE ${DOTNET_INCLUDE_DIRS})

2
ortools/constraint_solver/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE routing.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_constraint_solver
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/constraint_solver
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/constraint_solver
SOURCES routing.i)
#target_include_directories(dotnet_constraint_solver PRIVATE ${DOTNET_INCLUDE_DIRS})

14
ortools/dotnet/Google.OrTools.csproj.in
View File

@@ -31,43 +31,43 @@
</PropertyGroup>
<ItemGroup>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/algorithms/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/algorithms/*.cs">
<Link>algorithms/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/graph/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/graph/*.cs">
<Link>graph/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_SOURCE_DIR@/ortools/graph/csharp/*.cs">
<Link>graph/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/linear_solver/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/linear_solver/*.cs">
<Link>linear_solver/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_SOURCE_DIR@/ortools/linear_solver/csharp/*.cs">
<Link>linear_solver/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/constraint_solver/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/constraint_solver/*.cs">
<Link>constraint_solver/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_SOURCE_DIR@/ortools/constraint_solver/csharp/*.cs">
<Link>constraint_solver/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/init/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/init/*.cs">
<Link>init/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/sat/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/sat/*.cs">
<Link>sat/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_SOURCE_DIR@/ortools/sat/csharp/*.cs">
<Link>sat/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_DOTNET_DIR@/ortools/util/*.cs">
<Compile Include="@DOTNET_PROJECT_DIR@/util/*.cs">
<Link>util/%(Filename)%(Extension)</Link>
</Compile>
<Compile Include="@PROJECT_SOURCE_DIR@/ortools/util/csharp/*.cs">

2
ortools/graph/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE graph.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_graph
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/graph
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/graph
SOURCES graph.i)
#target_include_directories(dotnet_graph PRIVATE ${DOTNET_INCLUDE_DIRS})

2
ortools/init/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE init.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_init
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/init
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/init
SOURCES init.i)
#target_include_directories(dotnet_init PRIVATE ${DOTNET_INCLUDE_DIRS})

2
ortools/linear_solver/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE linear_solver.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_linear_solver
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/linear_solver
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/linear_solver
SOURCES linear_solver.i)
#target_include_directories(dotnet_linear_solver PRIVATE ${DOTNET_INCLUDE_DIRS})

2
ortools/sat/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE sat.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_sat
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/sat
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/sat
SOURCES sat.i)
#target_include_directories(dotnet_sat PRIVATE ${DOTNET_INCLUDE_DIRS})

2
ortools/util/csharp/CMakeLists.txt
View File

@@ -8,7 +8,7 @@ set_property(SOURCE sorted_interval_list.i PROPERTY COMPILE_OPTIONS
swig_add_library(dotnet_util
TYPE OBJECT
LANGUAGE csharp
OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/util
OUTPUT_DIR ${DOTNET_PROJECT_DIR}/util
SOURCES sorted_interval_list.i)
#target_include_directories(dotnet_util PRIVATE ${DOTNET_INCLUDE_DIRS})