Rework CMakeLists.txt

Dependencies:
- Add dependencies as subprojects instead of prebuild (aka imported target)
- add zlib project
- Use Cbc as CMake subproject instead of prebuilt
- Add log between each subproject
- Force gflags namespace to gflags

Or-tools:
- Rework python.cmake support
- Fix missing ortool.util in python (#558)
- Try to use static library for ortools::proto
pros: can use target_link_libraries to get includes etc...
cons: lot of symbols undefined since libortools.so will strip everything -_-
- Use add_library(XXX OBJECT) for ortools/*
- fix get version from git when using small depth copy
- Create Install rule for ortools
- Don't create export rules
note: since we use subprojects instead of Imported Target,
ortools export complained against target deps "that is not in the export set."

Update windows support
- add swig project
- Protobuf force the use of /MD instead of /MT
- or-tools use /MD by default
- Add missing ws2_32
- Add missing psapi
- Update windows disable warnings list
- Build Static or-tools on Windows
- fix windows export symbols leak issue

Signed-off-by: Corentin Le Molgat <corentinl@google.com>

CMakeLists.txt

@@ -1,83 +1,64 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.8)
+# This file is just an orchestration
+cmake_minimum_required(VERSION 3.8.2)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+# Default Build Type to be Release
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING
+		"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
+		FORCE)
+endif(NOT CMAKE_BUILD_TYPE)
 
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+# Use find_package everywhere, no-op if it's a subproject
+macro(find_package)
+	if(NOT TARGET ${ARGV0} AND NOT TARGET ${ARGV0}::${ARGV0})
+		_find_package(${ARGV})
+	else()
+		if(TARGET ${ARGV0})
+			get_target_property(TGT_VER ${ARGV0} VERSION)
+			set(TGT ${ARGV0})
+		else()
+			get_target_property(TGT_VER ${ARGV0}::${ARGV0} VERSION)
+			set(TGT ${ARGV0}::${ARGV0})
+		endif()
+		message(STATUS "Found ${ARGV0}: CMake Target ${TGT} (found version \"${TGT_VER}\")")
+		set(${ARGV0}_FOUND TRUE)
+	endif()
+endmacro()
+# Apple: Don't modify install_name when touching RPATH.
+if(POLICY CMP0068)
+	cmake_policy(SET CMP0068 NEW)
+endif()
 
-INCLUDE(cmake/utils.cmake)
-INCLUDE(GenerateExportHeader)
-INCLUDE(ExternalProject)
-INCLUDE(CMakePackageConfigHelpers)
+project(ortools-meta NONE)
 
-SET_VERSION(VERSION)
+include(CTest)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+if(UNIX)
+  # Needed to create python packagefrom the build directory
+	set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+	option(BUILD_SHARED_LIBS "Build shared libraries(.so)." ON)
+elseif(MSVC)
+	# Windows only support static build.
+ set(BUILD_SHARED_LIBS OFF)
+endif()
 
-PROJECT(ortools LANGUAGES CXX VERSION ${VERSION})
-SET(CMAKE_CXX_STANDARD 17)
+include(CMakeDependentOption)
+option(BUILD_DEPS "Force re-build of all dependencies" ON)
+option(BUILD_CXX "Build C++ library" ON)
+CMAKE_DEPENDENT_OPTION(BUILD_PYTHON "Build Python Library" ON "BUILD_CXX"	OFF)
+CMAKE_DEPENDENT_OPTION(BUILD_JAVA "Build Java Library" OFF "BUILD_CXX" OFF)
+CMAKE_DEPENDENT_OPTION(BUILD_CSHARP "Build CSharp Library" OFF "BUILD_CXX" OFF)
 
-IF(UNIX)
-    IF(NOT APPLE)
-        INCLUDE(GNUInstallDirs)
-    ELSE()
-        SET(CMAKE_INSTALL_LIBDIR lib)
-        SET(CMAKE_INSTALL_BINDIR bin)
-        SET(CMAKE_INSTALL_INCLUDEDIR include)
-    ENDIF()
-ELSE()
-    SET(CMAKE_INSTALL_LIBDIR lib)
-    SET(CMAKE_INSTALL_BINDIR bin)
-    SET(CMAKE_INSTALL_INCLUDEDIR include)
-ENDIF()
+message(STATUS "Build all dependencies: ${BUILD_DEPS}")
+message(STATUS "Build CXX library: ${BUILD_CXX}")
+message(STATUS "Build Python Binding: ${BUILD_PYTHON}")
+message(STATUS "Build Java Binding: ${BUILD_JAVA}")
+message(STATUS "Build CSharp Binding: ${BUILD_CSHARP}")
 
-SET(BUILD_CXX OFF CACHE BOOL "Build C++ library")
-SET(BUILD_PY OFF CACHE BOOL "Build Python library")
-SET(BUILD_DEPS OFF CACHE BOOL "Force re-build of all dependencies")
+# Build Dependencies
+add_subdirectory(cmake/external)
 
-SET(DOWNLOAD_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/downloads" CACHE PATH "Location where external projects will be downloaded.")
-MARK_AS_ADVANCED(DOWNLOAD_LOCATION)
-
-FILE(READ ${CMAKE_CURRENT_SOURCE_DIR}/Dependencies.txt _Dependency_file)
-FOREACH(DEPENDENCY Protobuf gflags glog Cbc CoinUtils Osi Clp Cgl)
-    STRING(REGEX REPLACE ".*${DEPENDENCY} = ([0-9.]+).*" "\\1" ${DEPENDENCY}_VERSION ${_Dependency_file})
-ENDFOREACH()
-
-IF(BUILD_PY)
-    FIND_PACKAGE(${PROJECT_NAME} QUIET)
-    IF(NOT ${PROJECT_NAME}_FOUND)
-        SET(BUILD_CXX ON)
-    ELSE()
-        IF(NOT BUILD_CXX)
-            INCLUDE_DIRECTORIES(${${PROJECT_NAME}_INCLUDE_DIRS})
-        ENDIF()
-    ENDIF()
-ENDIF()
-
-FIND_PACKAGE(Threads REQUIRED QUIET)
-
-FIND_PACKAGE(Protobuf ${Protobuf_VERSION} QUIET)
-IF(BUILD_DEPS)
-    SET(Protobuf_FOUND False)
-ENDIF()
-IF(NOT Protobuf_FOUND)
-    MESSAGE(STATUS "Did not find system protobuf or forced build. Building as an external project")
-    INCLUDE(cmake/external/protobuf.cmake)
-ENDIF()
-INCLUDE_DIRECTORIES(${Protobuf_INCLUDE_DIRS})
-SET(PROTOBUF_IMPORT_DIRS ${PROJECT_SOURCE_DIR})
-SET(PROTOBUF_GENERATE_CPP_APPEND_PATH OFF)
-
-IF(MSVC)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /DNDEBUG /DUSE_GLOP /DUSE_BOP")
-ELSE()
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fwrapv -DNDEBUG -DUSE_GLOP -DUSE_BOP")
-ENDIF()
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-
-MESSAGE(STATUS "Build cxx library: ${BUILD_CXX}")
-MESSAGE(STATUS "Build python library: ${BUILD_PY}")
-
-IF(BUILD_CXX)
-    INCLUDE(cmake/cpp.cmake)
-ENDIF()
-
-IF(BUILD_PY)
-    INCLUDE(cmake/python.cmake)
-ENDIF()
+include(cpp)
+include(python)
+include(java)
+include(csharp)

cmake/cpp.cmake

@@ -1,120 +1,191 @@
-INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR})
-FIND_PACKAGE(gflags ${gflags_VERSION})
-IF(BUILD_DEPS)
-    SET(gflags_FOUND False)
-ENDIF()
-IF(NOT gflags_FOUND)
-    MESSAGE(STATUS "Did not find system gflags or forced build. Building as an external project")
-    INCLUDE(cmake/external/gflags.cmake)
-ENDIF()
-INCLUDE_DIRECTORIES(${gflags_INCLUDE_DIRS})
+if(NOT BUILD_CXX)
+	return()
+endif()
 
-FIND_PACKAGE(glog ${glog_VERSION})
-IF(BUILD_DEPS)
-    SET(glog_FOUND False)
-ENDIF()
-IF(NOT glog_FOUND)
-    MESSAGE(STATUS "Did not find system glog. Building as an external project.")
-    INCLUDE(cmake/external/glog.cmake)
-ENDIF()
-INCLUDE_DIRECTORIES(${glog_INCLUDE_DIRS})
+include(utils)
+set_version(VERSION)
+project(ortools LANGUAGES CXX VERSION ${VERSION})
+message(STATUS "ortools version: ${PROJECT_VERSION}")
 
-FIND_PACKAGE(Cbc ${Cbc_VERSION})
-IF(BUILD_DEPS)
-    SET(Cbc_FOUND False)
-ENDIF()
-IF(NOT Cbc_FOUND)
-    IF(NOT MSVC)
-        MESSAGE(STATUS "Did not find system coin-cbc. Building as an external project.")
-        INCLUDE(cmake/external/cbc.cmake)
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CLP -DUSE_CBC")
-        INCLUDE_DIRECTORIES(${Cbc_INCLUDE_DIRS})
-    ENDIF()
-ELSE()
-    INCLUDE_DIRECTORIES(${Cbc_INCLUDE_DIRS})
-    IF(MSVC)
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DUSE_CLP /DUSE_CBC")
-    ELSE()
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CLP -DUSE_CBC")
-    ENDIF()
-ENDIF()
+# config options
+if(MSVC)
+	# Allow big object
+	add_definitions(/bigobj)
+	add_definitions(/DNOMINMAX /DWIN32_LEAN_AND_MEAN=1 /D_CRT_SECURE_NO_WARNINGS /D_CRT_SECURE_NO_DEPRECATE)
+	# Build with multiple processes
+	add_definitions(/MP)
+	# Prefer /MD over /MT and add NDEBUG in Release
+	if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+		add_definitions(/MDd)
+	else()
+		add_definitions(/MD /DNDEBUG)
+	endif()
+	# MSVC warning suppressions
+	add_definitions(
+		/wd4005 # 'macro-redefinition'
+		/wd4018 # 'expression' : signed/unsigned mismatch
+		/wd4065 # switch statement contains 'default' but no 'case' labels
+		/wd4068 # 'unknown pragma'
+		/wd4101 # 'identifier' : unreferenced local variable
+		/wd4146 # unary minus operator applied to unsigned type, result still unsigned
+		/wd4200 # nonstandard extension used : zero-sized array in struct/union
+		/wd4244 # 'conversion' conversion from 'type1' to 'type2', possible loss of data
+		/wd4251 # 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
+		/wd4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
+		/wd4305 # 'identifier' : truncation from 'type1' to 'type2'
+		/wd4307 # 'operator' : integral constant overflow
+		/wd4309 # 'conversion' : truncation of constant value
+		/wd4334 # 'operator' : result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
+		/wd4355 # 'this' : used in base member initializer list
+		/wd4477 # 'fwprintf' : format string '%s' requires an argument of type 'wchar_t *'
+		/wd4506 # no definition for inline function 'function'
+		/wd4715 # function' : not all control paths return a value
+		/wd4800 # 'type' : forcing value to bool 'true' or 'false' (performance warning)
+		/wd4996 # The compiler encountered a deprecated declaration.
+		)
+else()
+	add_definitions(-fwrapv)
+endif()
+add_definitions(-DUSE_GLOP -DUSE_BOP -DUSE_CBC -DUSE_CLP)
 
-FILE(GLOB_RECURSE proto_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "ortools/*.proto")
-PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS ${proto_files})
-ADD_CUSTOM_TARGET(${PROJECT_NAME}ProtoSources ALL DEPENDS ${PROTO_SRCS})
-ADD_LIBRARY(${PROJECT_NAME}Proto OBJECT ${PROTO_SRCS} ${PROTO_HDRS})
+# Verify Dependencies
+set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+find_package(Threads REQUIRED)
 
-IF(NOT Cbc_FOUND)
-    IF(NOT MSVC)
-        ADD_DEPENDENCIES(${PROJECT_NAME}Proto Cbc)
-    ENDIF()
-ENDIF()
+find_package(ZLIB REQUIRED)
+find_package(Protobuf REQUIRED)
+find_package(gflags REQUIRED)
+find_package(glog REQUIRED)
+find_package(Cbc REQUIRED)
 
-IF(NOT glog_FOUND)
-    ADD_DEPENDENCIES(${PROJECT_NAME}Proto glog)
-ENDIF()
+# Main Target
+if(BUILD_SHARED_LIBS)
+	add_library(${PROJECT_NAME} SHARED "")
+else()
+	add_library(${PROJECT_NAME} STATIC "")
+endif()
+if(NOT APPLE)
+	set_target_properties(${PROJECT_NAME} PROPERTIES VERSION ${PROJECT_VERSION})
+else()
+	# Clang don't support version x.y.z with z > 255
+	set_target_properties(${PROJECT_NAME} PROPERTIES VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR})
+endif()
+set_target_properties(${PROJECT_NAME} PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
+set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${PROJECT_NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_target_properties(${PROJECT_NAME} PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE ON)
+set_target_properties(${PROJECT_NAME} PROPERTIES INTERFACE_${PROJECT_NAME}_MAJOR_VERSION ${PROJECT_VERSION_MAJOR})
+set_target_properties(${PROJECT_NAME} PROPERTIES COMPATIBLE_INTERFACE_STRING ${PROJECT_NAME}_MAJOR_VERSION)
+if(APPLE)
+	set_target_properties(${PROJECT_NAME} PROPERTIES
+		INSTALL_RPATH
+		"@loader_path")
+endif()
+target_include_directories(${PROJECT_NAME} INTERFACE
+	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+	$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
+	$<INSTALL_INTERFACE:include>
+	)
+target_link_libraries(${PROJECT_NAME} PUBLIC
+	protobuf::libprotobuf gflags glog
+	Cbc::CbcSolver Cbc::OsiCbc Clp::ClpSolver Clp::OsiClp
+	Threads::Threads)
+if(WIN32)
+	target_link_libraries(${PROJECT_NAME} PRIVATE psapi.lib ws2_32.lib)
+endif()
+target_compile_definitions(${PROJECT_NAME}
+	PUBLIC	USE_BOP USE_GLOP USE_CBC USE_CLP)
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_11)
+add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
-SET_TARGET_PROPERTIES(${PROJECT_NAME}Proto PROPERTIES POSITION_INDEPENDENT_CODE ON)
+# Generate Protobuf cpp sources
+set(PROTO_HDRS)
+set(PROTO_SRCS)
+file(GLOB_RECURSE proto_files RELATIVE ${PROJECT_SOURCE_DIR} "ortools/*.proto")
+foreach (PROTO_FILE ${proto_files})
+	#message(STATUS "protoc proto(cc): ${PROTO_FILE}")
+	get_filename_component(PROTO_DIR ${PROTO_FILE} DIRECTORY)
+	get_filename_component(PROTO_NAME ${PROTO_FILE} NAME_WE)
+	set(PROTO_HDR ${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}.pb.h)
+	set(PROTO_SRC ${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}.pb.cc)
+	#message(STATUS "protoc hdr: ${PROTO_HDR}")
+	#message(STATUS "protoc src: ${PROTO_SRC}")
+	add_custom_command(
+		OUTPUT ${PROTO_SRC} ${PROTO_HDR}
+		COMMAND protobuf::protoc
+		"--proto_path=${PROJECT_SOURCE_DIR}"
+		"--cpp_out=${PROJECT_BINARY_DIR}"
+		${PROTO_FILE}
+		DEPENDS ${PROTO_FILE} protobuf::protoc
+		COMMENT "Running C++ protocol buffer compiler on ${PROTO_FILE}"
+		VERBATIM)
+	list(APPEND PROTO_HDRS ${PROTO_HDR})
+	list(APPEND PROTO_SRCS ${PROTO_SRC})
+endforeach()
+#add_library(${PROJECT_NAME}_proto STATIC ${PROTO_SRCS} ${PROTO_HDRS})
+add_library(${PROJECT_NAME}_proto OBJECT ${PROTO_SRCS} ${PROTO_HDRS})
+set_target_properties(${PROJECT_NAME}_proto PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_target_properties(${PROJECT_NAME}_proto PROPERTIES CXX_STANDARD 11)
+set_target_properties(${PROJECT_NAME}_proto PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${PROJECT_NAME}_proto PROPERTIES CXX_EXTENSIONS OFF)
+target_include_directories(${PROJECT_NAME}_proto PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	)
+#target_link_libraries(${PROJECT_NAME}_proto PRIVATE protobuf::libprotobuf)
+add_dependencies(${PROJECT_NAME}_proto protobuf::libprotobuf)
+add_library(${PROJECT_NAME}::proto ALIAS ${PROJECT_NAME}_proto)
+# Add ortools::proto to libortools
+#target_link_libraries(${PROJECT_NAME} PRIVATE ${PROJECT_NAME}::proto)
+target_sources(${PROJECT_NAME} PRIVATE $<TARGET_OBJECTS:${PROJECT_NAME}::proto>)
+add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}::proto)
 
-SET(SUBTARGETS "")
+foreach(SUBPROJECT
+		algorithms base bop	constraint_solver	data glop	graph	linear_solver	lp_data
+		port sat util)
+	add_subdirectory(ortools/${SUBPROJECT})
+	#target_link_libraries(${PROJECT_NAME} PRIVATE ${PROJECT_NAME}::${SUBPROJECT})
+	target_sources(${PROJECT_NAME} PRIVATE $<TARGET_OBJECTS:${PROJECT_NAME}::${SUBPROJECT}>)
+	add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}::${SUBPROJECT})
+endforeach()
 
-FOREACH(SUBPROJECT base util lp_data glop graph algorithms sat bop linear_solver constraint_solver)
-    ADD_SUBDIRECTORY(ortools/${SUBPROJECT})
-    LIST(APPEND SUBTARGETS "$<TARGET_OBJECTS:${PROJECT_NAME}_${SUBPROJECT}>")
-ENDFOREACH()
-
-LIST(APPEND SUBTARGETS "$<TARGET_OBJECTS:${PROJECT_NAME}Proto>")
-
-ADD_LIBRARY(${PROJECT_NAME} SHARED ${SUBTARGETS})
-TARGET_LINK_LIBRARIES(${PROJECT_NAME}
-        ${Cbc_LIBRARIES}
-        ${gflags_LIBRARIES}
-        ${Protobuf_LIBRARIES}
-        ${glog_LIBRARIES}
-        ${CMAKE_THREAD_LIBS_INIT})
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${PROJECT_NAME}Proto)
-ADD_SUBDIRECTORY(examples/cpp)
+# Install rules
+include(GNUInstallDirs)
 
+include(GenerateExportHeader)
 GENERATE_EXPORT_HEADER(${PROJECT_NAME})
-SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY VERSION ${PROJECT_VERSION})
-SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY SOVERSION ${PROJECT_VERSION_MAJOR})
-SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY INTERFACE_${PROJECT_NAME}_MAJOR_VERSION ${PROJECT_VERSION_MAJOR})
-SET_PROPERTY(TARGET ${PROJECT_NAME} APPEND PROPERTY COMPATIBLE_INTERFACE_STRING ${PROJECT_NAME}_MAJOR_VERSION)
+install(FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_export.h
+	DESTINATION	${CMAKE_INSTALL_INCLUDEDIR})
 
-INSTALL(TARGETS ${PROJECT_NAME}
-    EXPORT ${PROJECT_NAME}Targets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-INSTALL(DIRECTORY ortools
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-    COMPONENT Devel
-    FILES_MATCHING PATTERN "*.h")
-INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/ortools
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-    COMPONENT Devel
-    FILES_MATCHING PATTERN "*.pb.h"
-    PATTERN CMakeFiles EXCLUDE)
+install(TARGETS ${PROJECT_NAME}
+	INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)
+install(DIRECTORY ortools
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+	COMPONENT Devel
+	FILES_MATCHING
+	PATTERN "*.h")
+install(DIRECTORY ${PROJECT_BINARY_DIR}/ortools
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+	COMPONENT Devel
+	FILES_MATCHING
+	PATTERN "*.pb.h"
+	PATTERN CMakeFiles EXCLUDE)
 
-WRITE_BASIC_PACKAGE_VERSION_FILE("${CMAKE_CURRENT_BINARY_DIR}/ortools/${PROJECT_NAME}ConfigVersion.cmake"
-    VERSION ${PROJECT_VERSION}
-    COMPATIBILITY AnyNewerVersion)
-EXPORT(EXPORT ${PROJECT_NAME}Targets
-    FILE "${CMAKE_CURRENT_BINARY_DIR}/ortools/${PROJECT_NAME}Targets.cmake"
-    NAMESPACE ${PROJECT_NAME}::)
-CONFIGURE_FILE(cmake/${PROJECT_NAME}Config.cmake.in
-    "${CMAKE_CURRENT_BINARY_DIR}/ortools/${PROJECT_NAME}Config.cmake"
-    @ONLY)
-
-SET(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-INSTALL(EXPORT ${PROJECT_NAME}Targets
-    FILE ${PROJECT_NAME}Targets.cmake
-    NAMESPACE ${PROJECT_NAME}::
-    DESTINATION ${ConfigPackageLocation})
-INSTALL(FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/ortools/${PROJECT_NAME}Config.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/ortools/${PROJECT_NAME}ConfigVersion.cmake"
-    DESTINATION ${ConfigPackageLocation}
-    COMPONENT Devel)
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+	"${PROJECT_BINARY_DIR}/ortools/${PROJECT_NAME}ConfigVersion.cmake"
+	COMPATIBILITY SameMajorVersion
+	)
+install(
+	FILES
+	"${PROJECT_SOURCE_DIR}/ortools/cmake/${PROJECT_NAME}Config.cmake"
+	"${PROJECT_BINARY_DIR}/ortools/${PROJECT_NAME}ConfigVersion.cmake"
+	DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+	COMPONENT Devel)

cmake/csharp.cmake

@@ -0,0 +1,7 @@
+if (NOT BUILD_CSHARP)
+	return()
+endif()
+
+find_package(SWIG)
+find_package(CSharpUtilities)
+

cmake/dependencies.cmake

@@ -0,0 +1,81 @@
+enable_language(CXX)
+
+if (MSVC)
+    add_definitions(/bigobj /DNDEBUG /DUSE_GLOP /DUSE_BOP)
+else()
+    add_definitions(-fwrapv -DNDEBUG -DUSE_GLOP -DUSE_BOP)
+endif()
+
+if (NOT BUILD_DEPS)
+	return()
+endif()
+
+# Find or build Dependencies
+file(READ ${CMAKE_CURRENT_SOURCE_DIR}/Dependencies.txt _Dependency_file)
+foreach(DEPENDENCY Protobuf gflags glog Cbc CoinUtils Osi Clp Cgl)
+    string(REGEX REPLACE ".*${DEPENDENCY} = ([0-9.]+).*" "\\1" ${DEPENDENCY}_VERSION ${_Dependency_file})
+endforeach()
+
+if (MSVC)
+	include(external/zlib)
+	include(external/swig)
+endif()
+
+# Protobuf
+if (BUILD_DEPS)
+	set(Protobuf_FOUND False)
+else()
+	find_package(Protobuf ${Protobuf_VERSION})
+endif()
+if (NOT Protobuf_FOUND)
+	message(STATUS "Did not find system protobuf or forced build. Building as an external project")
+	include(external/protobuf)
+endif()
+#include_directories(${Protobuf_INCLUDE_DIRS})
+
+# gflags
+if (BUILD_DEPS)
+	set(gflags_FOUND False)
+else()
+	find_package(gflags ${gflags_VERSION})
+endif()
+if (NOT gflags_FOUND)
+	message(STATUS "Did not find system gflags or forced build. Building as an external project")
+	include(external/gflags)
+endif()
+#include_directories(${gflags_INCLUDE_DIRS})
+
+# glog
+if (BUILD_DEPS)
+	set(glog_FOUND False)
+else()
+	find_package(glog ${glog_VERSION})
+endif()
+if (NOT glog_FOUND)
+	message(STATUS "Did not find system glog or forced build. Building as an external project.")
+	include(external/glog)
+endif()
+#include_directories(${glog_INCLUDE_DIRS})
+
+# Cbc
+if (BUILD_DEPS)
+	set(Cbc_FOUND False)
+else()
+	find_package(Cbc ${Cbc_VERSION})
+endif()
+if (NOT Cbc_FOUND)
+	#if (NOT MSVC)
+	message(STATUS "Did not find system Cbc or forced build. Building as an external project.")
+	include(external/cbc)
+	#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CLP -DUSE_CBC")
+	#include_directories(${Cbc_INCLUDE_DIRS})
+	#endif()
+	#else()
+endif()
+#include_directories(${Cbc_INCLUDE_DIRS})
+#if (MSVC)
+#	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DUSE_CLP /DUSE_CBC")
+#else()
+#	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CLP -DUSE_CBC")
+#endif()
+#add_definitions("-DUSE_CLP -DUSE_CBC")

cmake/external/CMakeLists.txt

@@ -0,0 +1,191 @@
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Force dependencies to be static
+set(BUILD_SHARED_BCKP ${BUILD_SHARED_LIBS})
+set(BUILD_SHARED_LIBS OFF)
+
+# Disable test rules for dependencies
+set(BUILD_TESTING_BCKP ${CMAKE_SKIP_INSTALL_RULES})
+set(BUILD_TESTING OFF)
+
+# Disable install rules for dependencies
+# TODO Keep install rules of dependencies (and adapt them if needed)
+set(SKIP_INSTALL_BCKP ${CMAKE_SKIP_INSTALL_RULES})
+set(CMAKE_SKIP_INSTALL_RULES TRUE)
+
+# Build Dependencies
+#file(READ ${PROJECT_SOURCE_DIR}/Dependencies.txt _Dependency_file)
+#foreach(DEPENDENCY Protobuf gflags glog)
+#    string(REGEX REPLACE ".*${DEPENDENCY} = ([0-9.]+).*" "\\1" ${DEPENDENCY}_VERSION ${_Dependency_file})
+#endforeach()
+
+####################
+##  SWIG (WIN32)  ##
+####################
+if(WIN32)
+	message(STATUS "Subproject: Swig...")
+	# Download and unpack swig at configure time
+	configure_file(
+		${CMAKE_CURRENT_LIST_DIR}/swig.CMakeLists.txt
+		${CMAKE_BINARY_DIR}/swig-download/CMakeLists.txt)
+	execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+		RESULT_VARIABLE result
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/swig-download )
+	if(result)
+		message(FATAL_ERROR "CMake step for swig failed: ${result}")
+	endif()
+	execute_process(COMMAND ${CMAKE_COMMAND} --build .
+		RESULT_VARIABLE result
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/swig-download )
+	if(result)
+		message(FATAL_ERROR "Build step for swig failed: ${result}")
+	endif()
+
+	set(SWIG_EXECUTABLE ${CMAKE_BINARY_DIR}/swig/swig.exe
+		CACHE INTERNAL "swig.exe location" FORCE)
+	message(STATUS "Subproject: Swig...DONE")
+endif()
+
+##############
+##  GFLAGS  ##
+##############
+message(STATUS "Subproject: Gflag...")
+# Download and unpack gflags at configure time
+configure_file(
+	${CMAKE_CURRENT_SOURCE_DIR}/gflags.CMakeLists.txt
+	${CMAKE_BINARY_DIR}/gflags-download/CMakeLists.txt)
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/gflags-download)
+if(result)
+  message(FATAL_ERROR "CMake step for gflags failed: ${result}")
+endif()
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/gflags-download)
+if(result)
+  message(FATAL_ERROR "Build step for gflags failed: ${result}")
+endif()
+
+set(GFLAGS_NAMESPACE "gflags" CACHE INTERNAL "Namespace for gflags")
+add_subdirectory(
+	${CMAKE_BINARY_DIR}/gflags-src
+	${CMAKE_BINARY_DIR}/gflags-build
+	EXCLUDE_FROM_ALL)
+message(STATUS "Subproject: Gflag...DONE")
+
+############
+##  GLOG  ##
+############
+message(STATUS "Subproject: Glog...")
+# Download and unpack glog at configure time
+configure_file(
+	${CMAKE_CURRENT_SOURCE_DIR}/glog.CMakeLists.txt
+	${CMAKE_BINARY_DIR}/glog-download/CMakeLists.txt)
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/glog-download)
+if(result)
+  message(FATAL_ERROR "CMake step for glog failed: ${result}")
+endif()
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/glog-download)
+if(result)
+  message(FATAL_ERROR "Build step for glog failed: ${result}")
+endif()
+
+set(gflags_NAMESPACE "gflags" CACHE INTERNAL "Namespace for gflags")
+add_subdirectory(
+	${CMAKE_BINARY_DIR}/glog-src
+	${CMAKE_BINARY_DIR}/glog-build
+	EXCLUDE_FROM_ALL)
+message(STATUS "Subproject: Glog...DONE")
+
+############
+##  ZLIB  ##
+############
+message(STATUS "Subproject: ZLIB...")
+# Download and unpack zlib at configure time
+configure_file(
+	${CMAKE_CURRENT_SOURCE_DIR}/zlib.CMakeLists.txt
+	${CMAKE_BINARY_DIR}/zlib-download/CMakeLists.txt)
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/zlib-download)
+if(result)
+  message(FATAL_ERROR "CMake step for zlib failed: ${result}")
+endif()
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/zlib-download)
+if(result)
+  message(FATAL_ERROR "Build step for zlib failed: ${result}")
+endif()
+
+add_subdirectory(
+	${CMAKE_BINARY_DIR}/zlib-src
+	${CMAKE_BINARY_DIR}/zlib-build
+	EXCLUDE_FROM_ALL)
+message(STATUS "Subproject: ZLIB...DONE")
+
+################
+##  PROTOBUF  ##
+################
+message(STATUS "Subproject: Protobuf...")
+# Download and unpack protobuf at configure time
+configure_file(
+	${CMAKE_CURRENT_SOURCE_DIR}/protobuf.CMakeLists.txt
+	${CMAKE_BINARY_DIR}/protobuf-download/CMakeLists.txt)
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/protobuf-download )
+if(result)
+  message(FATAL_ERROR "CMake step for protobuf failed: ${result}")
+endif()
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/protobuf-download )
+if(result)
+  message(FATAL_ERROR "Build step for protobuf failed: ${result}")
+endif()
+
+set(protobuf_BUILD_TESTS OFF CACHE INTERNAL "Disable Protobuf tests")
+add_subdirectory(
+	${CMAKE_BINARY_DIR}/protobuf-src/cmake
+	${CMAKE_BINARY_DIR}/protobuf-build
+	EXCLUDE_FROM_ALL)
+message(STATUS "Subproject: Protobuf...DONE")
+
+###################
+##  COIN-OR:CBC  ##
+###################
+message(STATUS "Subproject: COIN-OR:Cbc...")
+# Download and unpack cbc at configure time
+configure_file(
+	${CMAKE_CURRENT_SOURCE_DIR}/cbc.CMakeLists.txt
+	${CMAKE_BINARY_DIR}/cbc-download/CMakeLists.txt)
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/cbc-download)
+if(result)
+  message(FATAL_ERROR "CMake step for cbc failed: ${result}")
+endif()
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/cbc-download)
+if(result)
+  message(FATAL_ERROR "Build step for cbc failed: ${result}")
+endif()
+
+add_subdirectory(
+	${CMAKE_BINARY_DIR}/cbc-src
+	${CMAKE_BINARY_DIR}/cbc-build
+	EXCLUDE_FROM_ALL)
+message(STATUS "Subproject: COIN-OR:Cbc...DONE")
+
+# Reapply previous state
+set(BUILD_SHARED_LIBS ${BUILD_SHARED_BCKP})
+set(BUILD_TESTING ${BUILD_TESTING_BCKP})
+set(CMAKE_SKIP_INSTALL_RULES ${SKIP_INSTALL_BCKP})

cmake/external/cbc.CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.5)
+
+# simplify variable expansion
+cmake_policy(SET CMP0053 NEW)
+cmake_policy(SET CMP0010 NEW)
+
+project(cbc-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(cbc_project
+	GIT_REPOSITORY https://github.com/Mizux/Cbc
+	GIT_TAG "master"
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/cbc-src"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/cbc-build"
+	UPDATE_COMMAND ""
+	#PATCH_COMMAND git apply "${CMAKE_SOURCE_DIR}/patches/cbc.patch"
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+	LOG_DOWNLOAD ON
+)

cmake/external/cbc.cmake

@@ -1,46 +0,0 @@
-SET(ADD_CXXFLAGS "-DCBC_THREAD_SAFE -DCBC_NO_INTERRUPT")
-
-FOREACH(COIN_PROJECT CoinUtils Osi Clp Cgl Cbc)
-    SET(${COIN_PROJECT}_URL https://github.com/coin-or/${COIN_PROJECT}.git)
-    SET(${COIN_PROJECT}_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/install/include/coin)
-
-    ExternalProject_Add(${COIN_PROJECT}_project
-            PREFIX ${COIN_PROJECT}
-            GIT_REPOSITORY ${${COIN_PROJECT}_URL}
-            GIT_TAG "releases/${${COIN_PROJECT}_VERSION}"
-            DOWNLOAD_DIR "${DOWNLOAD_LOCATION}"
-            UPDATE_COMMAND ""
-            BUILD_IN_SOURCE 1
-            CONFIGURE_COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${COIN_PROJECT}/src/${COIN_PROJECT}_project/configure
-            --enable-silent-rules --disable-bzlib --without-lapack --with-pic --enable-static --prefix=${CMAKE_CURRENT_BINARY_DIR}/install
-            ADD_CXXFLAGS=${ADD_CXXFLAGS})
-
-    ADD_LIBRARY(${COIN_PROJECT} STATIC IMPORTED)
-    SET_PROPERTY(TARGET ${COIN_PROJECT} PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/install/lib/lib${COIN_PROJECT}.a)
-
-    IF (${COIN_PROJECT} STREQUAL "Cbc" OR ${COIN_PROJECT} STREQUAL "Clp")
-        ADD_LIBRARY(Osi${COIN_PROJECT} STATIC IMPORTED)
-        SET_PROPERTY(TARGET Osi${COIN_PROJECT} PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/install/lib/libOsi${COIN_PROJECT}.a)
-        ADD_LIBRARY(${COIN_PROJECT}Solver STATIC IMPORTED)
-        SET_PROPERTY(TARGET ${COIN_PROJECT}Solver PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/install/lib/lib${COIN_PROJECT}Solver.a)
-    ENDIF()
-
-    ADD_DEPENDENCIES(${COIN_PROJECT} ${COIN_PROJECT}_project)
-ENDFOREACH()
-
-ADD_DEPENDENCIES(Osi_project CoinUtils_project)
-ADD_DEPENDENCIES(Clp_project Osi_project)
-ADD_DEPENDENCIES(Cgl_project Clp_project)
-ADD_DEPENDENCIES(Cbc_project Cgl_project)
-
-SET_PROPERTY(TARGET Osi PROPERTY INTERFACE_LINK_LIBRARIES CoinUtils)
-SET_PROPERTY(TARGET Clp PROPERTY INTERFACE_LINK_LIBRARIES Osi)
-SET_PROPERTY(TARGET OsiClp PROPERTY INTERFACE_LINK_LIBRARIES Clp)
-SET_PROPERTY(TARGET ClpSolver PROPERTY INTERFACE_LINK_LIBRARIES Clp)
-SET_PROPERTY(TARGET Cgl PROPERTY INTERFACE_LINK_LIBRARIES Clp)
-SET_PROPERTY(TARGET Cbc PROPERTY INTERFACE_LINK_LIBRARIES Cgl)
-SET_PROPERTY(TARGET OsiCbc PROPERTY INTERFACE_LINK_LIBRARIES Cbc)
-SET_PROPERTY(TARGET CbcSolver PROPERTY INTERFACE_LINK_LIBRARIES Cbc)
-
-SET(Cbc_LIBRARIES "")
-LIST(APPEND Cbc_LIBRARIES Cbc OsiCbc CbcSolver ClpSolver OsiClp)

cmake/external/gflags.CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.5)
+
+# simplify variable expansion
+cmake_policy(SET CMP0053 NEW)
+cmake_policy(SET CMP0010 NEW)
+
+project(gflags-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(gflags_project
+	GIT_REPOSITORY https://github.com/gflags/gflags
+	GIT_TAG "v2.2.1"
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/gflags-src"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/gflags-build"
+	UPDATE_COMMAND ""
+	PATCH_COMMAND ""
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+	LOG_DOWNLOAD ON
+)

cmake/external/gflags.cmake

@@ -1,31 +0,0 @@
-SET(gflags_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/gflags_project/src/gflags/include/)
-SET(gflags_URL https://github.com/gflags/gflags)
-
-IF(MSVC)
-    SET(gflags_ADDITIONAL_CMAKE_OPTIONS "-G \"NMake MakeFiles\"")
-ENDIF()
-
-ExternalProject_Add(gflags_project
-        PREFIX gflags
-        GIT_REPOSITORY ${gflags_URL}
-        GIT_TAG "v${gflags_VERSION}"
-        DOWNLOAD_DIR "${DOWNLOAD_LOCATION}"
-        UPDATE_COMMAND ""
-        BUILD_IN_SOURCE 1
-        SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/gflags_project/src/gflags
-        CONFIGURE_COMMAND ${CMAKE_COMMAND}
-        -DBUILD_STATIC_LIBS=ON
-        -DBUILD_TESTING=OFF
-        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-        ${gflags_ADDITIONAL_CMAKE_OPTIONS}
-        INSTALL_COMMAND ""
-        CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=Release
-        -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF
-        -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON)
-
-ADD_LIBRARY(gflags STATIC IMPORTED) 
-SET_PROPERTY(TARGET gflags PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/gflags_project/src/gflags/lib/libgflags.a)
-ADD_DEPENDENCIES(gflags gflags_project)
-SET(gflags_LIBRARIES "")
-LIST(APPEND gflags_LIBRARIES gflags)

cmake/external/glog.CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.5)
+
+# simplify variable expansion
+cmake_policy(SET CMP0053 NEW)
+cmake_policy(SET CMP0010 NEW)
+
+project(glog-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(glog_project
+	GIT_REPOSITORY https://github.com/google/glog
+	GIT_TAG "master"
+	#GIT_TAG "v0.3.5"
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/glog-src"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/glog-build"
+	UPDATE_COMMAND ""
+	PATCH_COMMAND git apply "${CMAKE_SOURCE_DIR}/patches/glog.patch"
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+	LOG_DOWNLOAD ON
+)

cmake/external/glog.cmake

@@ -1,42 +0,0 @@
-SET(glog_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/glog_project/src/glog/)
-LIST(APPEND glog_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/glog_project/src/glog/src/)
-SET(glog_URL https://github.com/google/glog)
-
-IF(NOT gflags_FOUND)
-    ExternalProject_Get_Property(gflags_project SOURCE_DIR)
-    SET(glog_ADDITIONAL_CMAKE_OPTIONS "-DCMAKE_PREFIX_PATH=${SOURCE_DIR}")
-ENDIF()
-
-IF(MSVC)
-    SET(gflags_ADDITIONAL_CMAKE_OPTIONS "${glog_ADDITIONAL_CMAKE_OPTIONS} -G \"NMake MakeFiles\"")
-ENDIF()
-
-ExternalProject_Add(glog_project
-        PREFIX glog
-        GIT_REPOSITORY ${glog_URL}
-        GIT_TAG "v${glog_VERSION}"
-        DOWNLOAD_DIR "${DOWNLOAD_LOCATION}"
-        UPDATE_COMMAND ""
-        PATCH_COMMAND git am -3 ${CMAKE_SOURCE_DIR}/patches/glog_includedir_fix.patch
-        BUILD_IN_SOURCE 1
-        SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/glog_project/src/glog
-        CONFIGURE_COMMAND ${CMAKE_COMMAND}
-        -DWITH_GFLAGS=ON
-        -DBUILD_TESTING=OFF
-        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-        ${glog_ADDITIONAL_CMAKE_OPTIONS}
-        INSTALL_COMMAND ""
-        CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=Release
-        -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF
-        -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON)
-
-IF(NOT gflags_FOUND)
-    ADD_DEPENDENCIES(glog_project gflags_project)
-ENDIF()
-
-ADD_LIBRARY(glog STATIC IMPORTED) 
-SET_PROPERTY(TARGET glog PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/glog_project/src/glog/libglog.a)
-ADD_DEPENDENCIES(glog glog_project)
-SET(glog_LIBRARIES "")
-LIST(APPEND glog_LIBRARIES glog)

cmake/external/protobuf.CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.5)
+
+# simplify variable expansion
+cmake_policy(SET CMP0053 NEW)
+cmake_policy(SET CMP0010 NEW)
+
+project(protobuf-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(protobuf_project
+	GIT_REPOSITORY https://github.com/google/protobuf
+	GIT_TAG "v3.5.0"
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/protobuf-src"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/protobuf-build"
+	UPDATE_COMMAND ""
+	PATCH_COMMAND git apply "${CMAKE_SOURCE_DIR}/patches/protobuf.patch"
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+	LOG_DOWNLOAD ON
+)

cmake/external/protobuf.cmake

@@ -1,40 +0,0 @@
-FIND_PACKAGE(ZLIB REQUIRED)
-
-SET(Protobuf_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/protobuf_project/src/protobuf/src)
-SET(Protobuf_URL https://github.com/google/protobuf)
-
-IF(MSVC)
-    SET(Protobuf_ADDITIONAL_CMAKE_OPTIONS "${Protobuf_ADDITIONAL_CMAKE_OPTIONS} -G \"NMake MakeFiles\"")
-ENDIF()
-
-ExternalProject_Add(Protobuf_project
-        PREFIX Protobuf
-        GIT_REPOSITORY ${Protobuf_URL}
-        GIT_TAG "v${Protobuf_VERSION}"
-        DOWNLOAD_DIR "${DOWNLOAD_LOCATION}"
-        UPDATE_COMMAND ""
-        BUILD_IN_SOURCE 1
-        SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/protobuf_project/src/protobuf
-        CONFIGURE_COMMAND ${CMAKE_COMMAND} cmake/
-        -Dprotobuf_BUILD_TESTS=OFF
-        -DBUILD_STATIC_LIBS=ON
-        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-        ${Protobuf_ADDITIONAL_CMAKE_OPTIONS}
-        INSTALL_COMMAND ""
-        CMAKE_CACHE_ARGS
-        -DCMAKE_BUILD_TYPE:STRING=Release
-        -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF
-        -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON)
-
-ADD_LIBRARY(Protobuf STATIC IMPORTED)
-SET_PROPERTY(TARGET Protobuf PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/protobuf_project/src/protobuf/libprotobuf.a)
-ADD_DEPENDENCIES(Protobuf Protobuf_project)
-SET(Protobuf_LIBRARIES "")
-LIST(APPEND Protobuf_LIBRARIES Protobuf ${ZLIB_LIBRARIES})
-
-UNSET(Protobuf_PROTOC_EXECUTABLE CACHE)
-ADD_EXECUTABLE(Protobuf_PROTOC_EXECUTABLE IMPORTED)
-SET_PROPERTY(TARGET Protobuf_PROTOC_EXECUTABLE PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/protobuf_project/src/protobuf/protoc)
-ADD_DEPENDENCIES(Protobuf_PROTOC_EXECUTABLE Protobuf_project)
-
-SET(Protobuf_PROTOC_EXECUTABLE Protobuf_PROTOC_EXECUTABLE)

cmake/external/swig.CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(swig-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(SWIG_project
+	URL "http://prdownloads.sourceforge.net/swig/swigwin-3.0.12.zip"
+	BUILD_IN_SOURCE 1
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/swig"
+	UPDATE_COMMAND ""
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+	LOG_DOWNLOAD ON
+	LOG_CONFIGURE ON
+	LOG_BUILD ON
+)

cmake/external/zlib.CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.5)
+
+# simplify variable expansion
+cmake_policy(SET CMP0053 NEW)
+cmake_policy(SET CMP0010 NEW)
+
+project(zlib-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(zlib_project
+	GIT_REPOSITORY "https://github.com/madler/zlib.git"
+	GIT_TAG "v1.2.11"
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/zlib-src"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/zlib-build"
+	UPDATE_COMMAND ""
+	PATCH_COMMAND patch < "${CMAKE_SOURCE_DIR}/patches/zlib.patch"
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+	LOG_DOWNLOAD ON
+)

cmake/java.cmake

@@ -0,0 +1,11 @@
+if (NOT BUILD_JAVA)
+	return()
+endif()
+
+find_package(SWIG REQUIRED)
+find_package(JAVA REQUIRED)
+find_package(JNI REQUIRED)
+
+if(NOT TARGET ortools::ortools)
+	message(FATAL_ERROR "Java: missing ortools TARGET")
+endif()

cmake/modules/FindCbc.cmake

@@ -1,51 +0,0 @@
-INCLUDE(FindPackageHandleStandardArgs)
-
-FOREACH(COIN_PROJECT CoinUtils Osi Clp Cgl Cbc)
-    SET(${COIN_PROJECT}_ROOT_DIR "" CACHE PATH "Path to Coin-OR ${COIN_PROJECT}")
-    IF(WIN32)
-        FIND_PATH(${COIN_PROJECT}_INCLUDE_DIR ${COIN_PROJECT}Config.h PATHS ${${COIN_PROJECT}_ROOT_DIR}/src/windows PATH_SUFFIXES coin ${COIN_PROJECT}/coin)
-    ELSE()
-        FIND_PATH(${COIN_PROJECT}_INCLUDE_DIR ${COIN_PROJECT}Config.h PATHS ${${COIN_PROJECT}_ROOT_DIR} PATH_SUFFIXES coin ${COIN_PROJECT}/coin)
-    ENDIF()
-ENDFOREACH()
-
-IF(Cbc_INCLUDE_DIR)
-    SET(_Cbc_COMMON_HEADER ${Cbc_INCLUDE_DIR}/CbcConfig.h)
-    SET(Cbc_VERSION "")
-    SET(Cbc_LIB_VERSION "")
-
-    FILE(STRINGS ${_Cbc_COMMON_HEADER} _Cbc_COMMON_H_CONTENTS REGEX "#define[ \t]+CBC_VERSION[ \t]+")
-
-    IF(_Cbc_COMMON_H_CONTENTS MATCHES "#define[ \t]+CBC_VERSION[ \t]+\"([0-9.]+)\"")
-        SET(Cbc_LIB_VERSION "${CMAKE_MATCH_1}")
-    ENDIF()
-
-    SET(Cbc_VERSION "${Cbc_LIB_VERSION}")
-ENDIF()
-
-IF(MSVC)
-    FIND_LIBRARY(Cbc_LIBRARY_RELEASE libCbc_static PATHS ${Cbc_ROOT_DIR} PATH_SUFFIXES Release)
-    FIND_LIBRARY(Cbc_LIBRARY_DEBUG libCbc_static PATHS ${Cbc_ROOT_DIR} PATH_SUFFIXES Debug)
-    SET(Cbc_LIBRARY OPTIMIZED ${Cbc_LIBRARY_RELEASE} DEBUG ${Cbc_LIBRARY_DEBUG})
-
-    FIND_LIBRARY(Cbc_Solver_LIBRARY_RELEASE libCbcSolver_static PATHS ${Cbc_ROOT_DIR} PATH_SUFFIXES Release)
-    FIND_LIBRARY(Cbc_solver_LIBRARY_DEBUG libCbcSolver_static PATHS ${Cbc_ROOT_DIR} PATH_SUFFIXES Debug)
-    SET(Cbc_Solver__LIBRARY OPTIMIZED ${Cbc_Solver__LIBRARY_RELEASE} DEBUG ${Cbc_Solver__LIBRARY_DEBUG})
-ELSE()
-    FIND_LIBRARY(Cbc_LIBRARY NAMES Cbc libCBC PATHS ${Cbc_ROOT_DIR} PATH_SUFFIXES lib lib64)
-    FIND_LIBRARY(Cbc_Solver_LIBRARY NAMES CbcSolver libCbcSolver PATHS ${Cbc_ROOT_DIR} PATH_SUFFIXES lib lib64)
-ENDIF()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Cbc
-    REQUIRED_VARS Cbc_INCLUDE_DIR Cbc_LIBRARY Cbc_Solver_LIBRARY
-    VERSION_VAR Cbc_VERSION)
-
-IF(Cbc_FOUND)
-    SET(Cbc_INCLUDE_DIRS ${Cbc_INCLUDE_DIR})
-    FOREACH(COIN_PROJECT CoinUtils Osi Clp Cgl)
-        LIST(APPEND Cbc_INCLUDE_DIRS ${${COIN_PROJECT}_INCLUDE_DIR})
-    ENDFOREACH()
-
-    SET(Cbc_LIBRARIES "${Cbc_LIBRARY};${Cbc_Solver_LIBRARY}")
-    MARK_AS_ADVANCED(Cbc_ROOT_DIR Cbc_LIBRARY_RELEASE Cbc_LIBRARY_DEBUG Cbc_LIBRARY Cbc_INCLUDE_DIR)
-ENDIF()

cmake/modules/Findglog.cmake

@@ -1,29 +0,0 @@
-# Glog doesn't seem to provide any versioning information in its source tree.
-# Thus we do not extract version
-
-INCLUDE(FindPackageHandleStandardArgs)
-
-SET(glog_ROOT_DIR "" CACHE PATH "Path to Google glog")
-
-IF(WIN32)
-    FIND_PATH(glog_INCLUDE_DIR glog/logging.h PATHS ${glog_ROOT_DIR}/src/windows)
-ELSE()
-    FIND_PATH(glog_INCLUDE_DIR glog/logging.h PATHS ${glog_ROOT_DIR})
-ENDIF()
-
-IF(MSVC)
-    FIND_LIBRARY(glog_LIBRARY_RELEASE libglog_static PATHS ${glog_ROOT_DIR} PATH_SUFFIXES Release)
-    FIND_LIBRARY(glog_LIBRARY_DEBUG libglog_static PATHS ${glog_ROOT_DIR} PATH_SUFFIXES Debug)
-
-    SET(glog_LIBRARY OPTIMIZED ${glog_LIBRARY_RELEASE} DEBUG ${glog_LIBRARY_DEBUG})
-ELSE()
-    FIND_LIBRARY(glog_LIBRARY glog PATHS ${glog_ROOT_DIR} PATH_SUFFIXES lib lib64)
-ENDIF()
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(glog DEFAULT_MSG glog_INCLUDE_DIR glog_LIBRARY)
-
-IF(glog_FOUND)
-    SET(glog_INCLUDE_DIRS ${glog_INCLUDE_DIR})
-    SET(glog_LIBRARIES ${glog_LIBRARY})
-    MARK_AS_ADVANCED(glog_ROOT_DIR glog_LIBRARY_RELEASE glog_LIBRARY_DEBUG glog_LIBRARY glog_INCLUDE_DIR)
-ENDIF()

cmake/python.cmake

@@ -1,79 +1,149 @@
-INCLUDE(FindPythonInterp)
+if(NOT BUILD_PYTHON)
+	return()
+endif()
 
-FILE(GLOB_RECURSE py_proto_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ortools/constraint_solver/*.proto ortools/linear_solver/*.proto)
-LIST(REMOVE_ITEM py_proto_files "ortools/constraint_solver/demon_profiler.proto")
-PROTOBUF_GENERATE_PYTHON(PROTO_PY_SRCS ${py_proto_files})
-ADD_CUSTOM_TARGET(Py${PROJECT_NAME}proto ALL DEPENDS ${PROTO_PY_SRCS})
+if(NOT TARGET ortools::ortools)
+	message(FATAL_ERROR "Python: missing ortools TARGET")
+endif()
 
-IF(BUILD_CXX)
-    ADD_DEPENDENCIES(Py${PROJECT_NAME}proto ${PROJECT_NAME})
-ENDIF()
+# Will need swig
+find_package(SWIG REQUIRED)
+include(UseSWIG)
 
-IF(${PYTHON_VERSION_STRING} VERSION_GREATER 3)
-    SET(CMAKE_SWIG_FLAGS "-py3;-DPY3")
-ENDIF()
+# Generate Protobuf py sources
+set(PROTO_PYS)
+file(GLOB_RECURSE proto_py_files RELATIVE ${PROJECT_SOURCE_DIR}
+	"ortools/constraint_solver/*.proto"
+	"ortools/linear_solver/*.proto"
+	"ortools/sat/*.proto"
+	"ortools/util/*.proto"
+	)
+list(REMOVE_ITEM proto_py_files "ortools/constraint_solver/demon_profiler.proto")
+foreach(PROTO_FILE ${proto_py_files})
+	#message(STATUS "protoc proto(py): ${PROTO_FILE}")
+	get_filename_component(PROTO_DIR ${PROTO_FILE} DIRECTORY)
+	get_filename_component(PROTO_NAME ${PROTO_FILE} NAME_WE)
+	set(PROTO_PY ${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}_pb2.py)
+	#message(STATUS "protoc py: ${PROTO_PY}")
+	add_custom_command(
+		OUTPUT ${PROTO_PY}
+		COMMAND protobuf::protoc
+		"--proto_path=${PROJECT_SOURCE_DIR}"
+		"--python_out=${PROJECT_BINARY_DIR}"
+		${PROTO_FILE}
+		DEPENDS ${PROTO_FILE} protobuf::protoc
+		COMMENT "Running C++ protocol buffer compiler on ${PROTO_FILE}"
+		VERBATIM)
+	list(APPEND PROTO_PYS ${PROTO_PY})
+endforeach()
+add_custom_target(Py${PROJECT_NAME}_proto DEPENDS ${PROTO_PYS} ortools::ortools)
 
-INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
+# Setup Python
+set(Python_ADDITIONAL_VERSIONS "3.6;3.5;2.7" CACHE STRING "Python to use for binding")
+find_package(PythonInterp REQUIRED)
+# Force PythonLibs to find the same version than the python interpreter.
+set(Python_ADDITIONAL_VERSIONS "${PYTHON_VERSION_STRING}")
+# PythonLibs require enable_language(CXX)
+enable_language(CXX)
+find_package(PythonLibs REQUIRED)
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools/__init__.py
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/ortools/)
+if(${PYTHON_VERSION_STRING} VERSION_GREATER 3)
+	set(CMAKE_SWIG_FLAGS "-py3;-DPY3")
+endif()
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools/__init__.py
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/ortools/constraint_solver/)
+# CMake will remove all '-D' prefix (i.e. -DUSE_FOO become USE_FOO)
+#get_target_property(FLAGS ortools::ortools COMPILE_DEFINITIONS)
+set(FLAGS -DUSE_BOP -DUSE_GLOP -DUSE_CBC -DUSE_CLP)
+list(APPEND CMAKE_SWIG_FLAGS ${FLAGS} "-I${PROJECT_SOURCE_DIR}")
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools/__init__.py
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/ortools/linear_solver/)
+foreach(SUBPROJECT constraint_solver linear_solver sat graph algorithms data)
+	add_subdirectory(ortools/${SUBPROJECT}/python)
+endforeach()
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools/__init__.py
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/ortools/graph/)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/util COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/constraint_solver/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/linear_solver/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/sat/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/sat/python COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/graph/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/algorithms/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/__init__.py ${PROJECT_BINARY_DIR}/ortools/data/ COPYONLY)
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools/__init__.py
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/ortools/algorithms/)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/linear_solver/linear_solver_natural_api.py
+	${PROJECT_BINARY_DIR}/ortools/linear_solver/ COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/sat/python/cp_model.py
+	${PROJECT_BINARY_DIR}/ortools/sat/python COPYONLY)
+configure_file(${PROJECT_SOURCE_DIR}/ortools/sat/python/visualization.py
+	${PROJECT_BINARY_DIR}/ortools/sat/python COPYONLY)
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}
-    FILES_MATCHING
-    PATTERN
-    "*.i")
+# To use a cmake generator expression (aka $<>), it must be processed at build time
+# i.e. inside a add_custom_command()
+# This command will depend on TARGET(s) in cmake generator expression
+add_custom_command(OUTPUT setup.py dist ${PROJECT_NAME}.egg-info
+	COMMAND ${CMAKE_COMMAND} -E echo "from setuptools import dist, find_packages, setup" > setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "class BinaryDistribution(dist.Distribution):" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  def is_pure(self):" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "    return False" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  def has_ext_modules(self):" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "    return True" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "setup(" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  name='ortools'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  license='Apache 2.0'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  version='${PROJECT_VERSION}'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  author='Google Inc'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  author_email = 'lperron@google.com'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  description = 'Google OR-Tools python libraries and modules'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  long_description = 'read(README.txt)'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  keywords = ('operations research' +" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  ', constraint programming' +" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  ', linear programming' +" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  ', flow algoritms' +" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  ', python')," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  url = 'https://developers.google.com/optimization/'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  download_url = 'https://github.com/google/or-tools/releases'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  distclass=BinaryDistribution," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  packages=find_packages()," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  package_data={" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools':['$<TARGET_FILE_NAME:ortools>'$<$<NOT:$<PLATFORM_ID:Windows>>:,'$<TARGET_SONAME_FILE:ortools>'>]," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools.constraint_solver':['$<TARGET_FILE_NAME:_pywrapcp>']," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools.linear_solver':['$<TARGET_FILE_NAME:_pywraplp>']," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools.sat':['$<TARGET_FILE_NAME:_pywrapsat>']," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools.graph':['$<TARGET_FILE_NAME:_pywrapgraph>']," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools.algorithms':['$<TARGET_FILE_NAME:_pywrapknapsack_solver>']," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "	'ortools.data':['$<TARGET_FILE_NAME:_pywraprcpsp>']," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  }," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  include_package_data=True," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  install_requires=[" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'protobuf >= ${Protobuf_VERSION}'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'six >= 1.10'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  ]," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  classifiers=[" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Development Status :: 5 - Production/Stable'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Intended Audience :: Developers'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'License :: OSI Approved :: Apache Software License'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Operating System :: POSIX :: Linux'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Operating System :: MacOS :: MacOS X'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Operating System :: Microsoft :: Windows'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Programming Language :: Python :: 2'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Programming Language :: Python :: 2.7'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Programming Language :: Python :: 3'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Programming Language :: Python :: 3.5'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Programming Language :: Python :: 3.6'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Topic :: Office/Business :: Scheduling'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Topic :: Scientific/Engineering'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Topic :: Scientific/Engineering :: Mathematics'," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  'Topic :: Software Development :: Libraries :: Python Modules'" >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo "  ]," >> setup.py
+	COMMAND ${CMAKE_COMMAND} -E echo ")" >> setup.py
+	VERBATIM)
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/README
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR})
+# Main Target
+add_custom_target(bdist ALL
+	DEPENDS setup.py Py${PROJECT_NAME}_proto
+	COMMAND ${PYTHON_EXECUTABLE} setup.py bdist
+	COMMAND ${PYTHON_EXECUTABLE} setup.py bdist_wheel
+	)
 
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/ortools/linear_solver/linear_solver_natural_api.py
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/ortools/linear_solver/)
-
-FILE(COPY
-    ${CMAKE_CURRENT_SOURCE_DIR}/python/MANIFEST.in
-    DESTINATION
-    ${CMAKE_CURRENT_BINARY_DIR}/)
-SET(README_FILE README)
-
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py.in ${CMAKE_CURRENT_BINARY_DIR}/setup.py)
-
-SET(PY_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/timestamp)
-ADD_CUSTOM_COMMAND(
-    OUTPUT ${PY_OUTPUT}
-    COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/setup.py sdist
-    COMMAND ${CMAKE_COMMAND} -E touch ${PY_OUTPUT}
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/ortools/__init__.py)
-ADD_CUSTOM_TARGET(py${PROJECT_NAME} ALL DEPENDS ${PY_OUTPUT})
-
-IF(BUILD_CXX)
-    ADD_DEPENDENCIES(py${PROJECT_NAME} ${PROJECT_NAME})
-ENDIF()

cmake/utils.cmake

@@ -1,64 +1,63 @@
-FUNCTION(GET_VERSION_FROM_FILE VERSION_MAJOR VERSION_MINOR VERSION_PATCH)
-    FILE(STRINGS "Version.txt" VERSION_DESC)
-    FOREACH(_VERSION_DESC ${VERSION_DESC})
-        IF(${_VERSION_DESC} MATCHES "OR_TOOLS_MAJOR = (.*)")
-            SET(${VERSION_MAJOR} ${CMAKE_MATCH_1} PARENT_SCOPE)
-        ENDIF()
+function(get_version_from_file VERSION_MAJOR VERSION_MINOR VERSION_PATCH)
+	file(STRINGS "Version.txt" VERSION_STR)
+	foreach(STR ${VERSION_STR})
+		if(${STR} MATCHES "OR_TOOLS_MAJOR = (.*)")
+			set(${VERSION_MAJOR} ${CMAKE_MATCH_1} PARENT_SCOPE)
+		endif()
+		if(${STR} MATCHES "OR_TOOLS_MINOR = (.*)")
+			set(${VERSION_MINOR} ${CMAKE_MATCH_1} PARENT_SCOPE)
+		endif()
+	endforeach()
+	set(${VERSION_PATCH} 999 PARENT_SCOPE)
+endfunction()
 
-        IF(${_VERSION_DESC} MATCHES "OR_TOOLS_MINOR = (.*)")
-            SET(${VERSION_MINOR} ${CMAKE_MATCH_1} PARENT_SCOPE)
-        ENDIF()
-    ENDFOREACH()
-ENDFUNCTION()
+function(get_version_from_git VERSION_MAJOR VERSION_MINOR VERSION_PATCH)
+	find_package(Git QUIET)
+	if(NOT GIT_FOUND)
+		message(STATUS "Did not find git package, get version from file...")
+		get_version_from_file(MAJOR MINOR PATCH)
+	else()
+		execute_process(COMMAND
+			${GIT_EXECUTABLE}
+			"describe" "--tags"
+			RESULT_VARIABLE _OUTPUT_VAR
+			OUTPUT_VARIABLE FULL
+			ERROR_QUIET)
+		if(NOT _OUTPUT_VAR)
+			execute_process(COMMAND
+				${GIT_EXECUTABLE}
+				"rev-list" "HEAD" "--count"
+				RESULT_VARIABLE _OUTPUT_VAR
+				OUTPUT_VARIABLE PATCH
+				ERROR_QUIET)
+			STRING(STRIP PATCH ${PATCH})
+			STRING(REGEX REPLACE "\n$" "" PATCH ${PATCH})
+			STRING(REGEX REPLACE " " "" PATCH ${PATCH})
+			STRING(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" MAJOR "${FULL}")
+			STRING(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" MINOR "${FULL}")
+		else()
+			message(STATUS "Did not find any tag")
+			get_version_from_file(MAJOR MINOR PATCH)
+		endif()
+	endif()
+	set(${VERSION_MAJOR} ${MAJOR} PARENT_SCOPE)
+	set(${VERSION_MINOR} ${MINOR} PARENT_SCOPE)
+	set(${VERSION_PATCH} ${PATCH} PARENT_SCOPE)
+endfunction()
 
-FUNCTION(GET_VERSION_FROM_GIT OUTPUT_VAR VERSION_MAJOR_ VERSION_MINOR_ VERSION_PATCH_)
-    FIND_PACKAGE(Git QUIET)
-    IF(GIT_FOUND)
-        EXECUTE_PROCESS(COMMAND
-            ${GIT_EXECUTABLE}
-            "describe" "--tags"
-            RESULT_VARIABLE _OUTPUT_VAR
-            OUTPUT_VARIABLE VERSION_FULL
-            ERROR_QUIET)
+function(set_version VERSION)
+	get_filename_component(GIT_DIR ".git" ABSOLUTE)
+	if(EXISTS ${GIT_DIR})
+		get_version_from_git(MAJOR MINOR PATCH)
+	else()
+		get_version_from_file(MAJOR MINOR PATCH)
+	endif()
+	set(${VERSION} "${MAJOR}.${MINOR}.${PATCH}" PARENT_SCOPE)
+endfunction()
 
-        IF(NOT _OUTPUT_VAR)
-            EXECUTE_PROCESS(COMMAND
-                ${GIT_EXECUTABLE}
-                "log" "--oneline"
-                COMMAND
-                "wc"
-                "-l"
-                RESULT_VARIABLE _OUTPUT_VAR
-                OUTPUT_VARIABLE _VERSION_PATCH
-                ERROR_QUIET)
-            STRING(STRIP _VERSION_PATCH ${_VERSION_PATCH})
-            STRING(REGEX REPLACE "\n$" "" _VERSION_PATCH ${_VERSION_PATCH})
-            STRING(REGEX REPLACE " " "" _VERSION_PATCH ${_VERSION_PATCH})
-            STRING(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" _VERSION_MAJOR "${VERSION_FULL}")
-            STRING(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" _VERSION_MINOR "${VERSION_FULL}")
-
-            SET(${VERSION_MAJOR_} "${_VERSION_MAJOR}" PARENT_SCOPE)
-            SET(${VERSION_MINOR_} "${_VERSION_MINOR}" PARENT_SCOPE)
-            SET(${VERSION_PATCH_} "${_VERSION_PATCH}" PARENT_SCOPE)
-        ENDIF()
-    ENDIF()
-    SET(${OUTPUT_VAR} "${_OUTPUT_VAR}" PARENT_SCOPE)
-ENDFUNCTION()
-
-FUNCTION(SET_VERSION VERSION)
-    FIND_PACKAGE(Git QUIET)
-    IF(GIT_FOUND)
-        GET_VERSION_FROM_GIT(GIT_OUTPUT VERSION_MAJOR VERSION_MINOR VERSION_PATCH)
-
-        IF(GIT_OUTPUT)
-            GET_VERSION_FROM_FILE(VERSION_MAJOR VERSION_MINOR VERSION_PATCH)
-        ENDIF()
-    ELSE()
-        GET_VERSION_FROM_FILE(VERSION_MAJOR VERSION_MINOR VERSION_PATCH)
-    ENDIF()
-    SET(_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}")
-    IF(VERSION_PATCH)
-        SET(_VERSION "${_VERSION}.${VERSION_PATCH}")
-    ENDIF()
-    SET(${VERSION} ${_VERSION} PARENT_SCOPE)
-ENDFUNCTION()
+function(check_target my_target)
+	if(NOT TARGET ${my_target})
+		message(FATAL_ERROR " Or-Tools: compiling Or-Tools requires a ${my_target}
+		CMake target in your project, see CMake/README.md for more details")
+	endif(NOT TARGET ${my_target})
+endfunction()

ortools/algorithms/CMakeLists.txt

@@ -1,11 +1,45 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_algorithms)
+file(GLOB _SRCS "*.h" "*.cc")
+list(REMOVE_ITEM _SRCS ${CMAKE_CURRENT_SOURCE_DIR}/hungarian_test.cc
+	${CMAKE_CURRENT_SOURCE_DIR}/hungarian_test.h)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-LIST(REMOVE_ITEM ${PROJECT_NAME}_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/hungarian_test.cc")
+set(NAME ${PROJECT_NAME}_algorithms)
 
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::algorithms ALIAS ${NAME})

ortools/algorithms/python/CMakeLists.txt

@@ -1,9 +1,49 @@
-IF(BUILD_PYTHON)
-    SET_PROPERTY(SOURCE knapsack_solver.i PROPERTY CPLUSPLUS ON)
-    SET_PROPERTY(SOURCE knapsack_solver.i PROPERTY SWIG_MODULE_NAME pywrapknapsack_solver)
+# Setup SWIG
+find_package(SWIG REQUIRED)
+include(UseSWIG)
 
-    SWIG_ADD_LIBRARY(pywrapknapsack_solver TYPE MODULE LANGUAGE python SOURCES knapsack_solver.i)
-    SWIG_LINK_LIBRARIES(pywrapknapsack_solver ${PROJECT_NAME})
+# Setup Python
+find_package(PythonInterp REQUIRED)
+find_package(PythonLibs REQUIRED)
 
-    INSTALL(TARGETS _pywrapknapsack_solver DESTINATION ${PYTHON_MODULE_PATH})
-ENDIF(BUILD_PYTHON)
+set_property(SOURCE knapsack_solver.i PROPERTY CPLUSPLUS ON)
+list(APPEND CMAKE_SWIG_FLAGS "-module;pywrapknapsack_solver")
+# outdir for .py file
+set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/..)
+# outdir for .so file
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+# Second, for multi-config builds (e.g. msvc)
+foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+endforeach()
+
+if(${CMAKE_VERSION} VERSION_GREATER 3.8.2)
+	swig_add_library(pywrapknapsack_solver
+		TYPE SHARED
+		LANGUAGE python
+		SOURCES knapsack_solver.i)
+else()
+	swig_add_module(pywrapknapsack_solver python knapsack_solver.i)
+endif()
+
+# ${SWIG_MODULE_<name>_REAL_NAME} will resolve to _<name>.so TARGET
+target_include_directories(${SWIG_MODULE_pywrapknapsack_solver_REAL_NAME} PRIVATE
+	${PYTHON_INCLUDE_DIRS})
+target_link_libraries(${SWIG_MODULE_pywrapknapsack_solver_REAL_NAME} PRIVATE
+	ortools::ortools ${PYTHON_LIBRARIES})
+if(UNIX)
+	if(NOT APPLE)
+		set_target_properties(${SWIG_MODULE_pywrapknapsack_solver_REAL_NAME} PROPERTIES
+			INSTALL_RPATH "$ORIGIN/../../:$ORIGIN")
+	else()
+		set_target_properties(${SWIG_MODULE_pywrapknapsack_solver_REAL_NAME} PROPERTIES
+			SUFFIX ".so"
+			INSTALL_RPATH	"@loader_path/../..:@loader_path")
+		set_property(TARGET ${SWIG_MODULE_pywrapknapsack_solver_REAL_NAME} APPEND PROPERTY
+			LINK_FLAGS "-flat_namespace -undefined suppress")
+	endif()
+endif()

ortools/base/CMakeLists.txt

@@ -1,10 +1,46 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_base)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_base)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:ZLIB::ZLIB,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:ZLIB::ZLIB,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:ZLIB::ZLIB,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  ZLIB::ZLIB
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	ZLIB::ZLIB protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::base ALIAS ${NAME})

ortools/bop/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_bop)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_bop)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::bop ALIAS ${NAME})

ortools/constraint_solver/CMakeLists.txt

@@ -1,10 +1,46 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_constraint_solver)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_constraint_solver)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:ZLIB::ZLIB,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:ZLIB::ZLIB,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:ZLIB::ZLIB,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  ZLIB::ZLIB
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	ZLIB::ZLIB protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::constraint_solver ALIAS ${NAME})

ortools/constraint_solver/python/CMakeLists.txt

@@ -1,9 +1,46 @@
-IF(BUILD_PYTHON)
-    SET_PROPERTY(SOURCE routing.i PROPERTY CPLUSPLUS ON)
-    SET_PROPERTY(SOURCE routing.i PROPERTY SWIG_MODULE_NAME pywrapcp)
+# Setup SWIG
+find_package(SWIG REQUIRED)
+include(UseSWIG)
 
-    SWIG_ADD_LIBRARY(pywrapcp TYPE MODULE LANGUAGE python SOURCES routing.i)
-    SWIG_LINK_LIBRARIES(pywrapcp ${PROJECT_NAME})
+# Setup Python
+find_package(PythonInterp REQUIRED)
+find_package(PythonLibs REQUIRED)
 
-    INSTALL(TARGETS _pywrapcp DESTINATION ${PYTHON_MODULE_PATH})
-ENDIF(BUILD_PYTHON)
+set_property(SOURCE routing.i PROPERTY CPLUSPLUS ON)
+list(APPEND CMAKE_SWIG_FLAGS "-module;pywrapcp")
+# outdir for .py file
+set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/..)
+# outdir for .so file
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+# Second, for multi-config builds (e.g. msvc)
+foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+endforeach()
+
+if(${CMAKE_VERSION} VERSION_GREATER 3.8.2)
+	swig_add_library(pywrapcp TYPE SHARED LANGUAGE python SOURCES routing.i)
+else()
+	swig_add_module(pywrapcp python routing.i)
+endif()
+
+# ${SWIG_MODULE_<name>_REAL_NAME} will resolve to _<name>.so TARGET
+target_include_directories(${SWIG_MODULE_pywrapcp_REAL_NAME} PRIVATE
+	${PYTHON_INCLUDE_DIRS})
+target_link_libraries(${SWIG_MODULE_pywrapcp_REAL_NAME} PRIVATE
+	ortools::ortools ${PYTHON_LIBRARIES})
+if(UNIX)
+	if(NOT APPLE)
+		set_target_properties(${SWIG_MODULE_pywrapcp_REAL_NAME} PROPERTIES
+			INSTALL_RPATH "$ORIGIN/../../:$ORIGIN")
+	else()
+		set_target_properties(${SWIG_MODULE_pywrapcp_REAL_NAME} PROPERTIES
+			SUFFIX ".so"
+			INSTALL_RPATH	"@loader_path/../..:@loader_path")
+		set_property(TARGET ${SWIG_MODULE_pywrapcp_REAL_NAME} APPEND PROPERTY
+			LINK_FLAGS "-flat_namespace -undefined suppress")
+	endif()
+endif()

ortools/data/CMakeLists.txt

@@ -0,0 +1,42 @@
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_data)
+
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::data ALIAS ${NAME})

ortools/data/python/CMakeLists.txt

@@ -0,0 +1,46 @@
+# Setup SWIG
+find_package(SWIG REQUIRED)
+include(UseSWIG)
+
+# Setup Python
+find_package(PythonInterp REQUIRED)
+find_package(PythonLibs REQUIRED)
+
+set_property(SOURCE rcpsp.i PROPERTY CPLUSPLUS ON)
+list(APPEND CMAKE_SWIG_FLAGS "-module;pywraprcpsp")
+# outdir for .py file
+set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/..)
+# outdir for .so file
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+# Second, for multi-config builds (e.g. msvc)
+foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+endforeach()
+
+if(${CMAKE_VERSION} VERSION_GREATER 3.8.2)
+	swig_add_library(pywraprcpsp TYPE SHARED LANGUAGE python SOURCES rcpsp.i)
+else()
+	swig_add_module(pywraprcpsp python rcpsp.i)
+endif()
+
+# ${SWIG_MODULE_<name>_REAL_NAME} will resolve to _<name>.so TARGET
+target_include_directories(${SWIG_MODULE_pywraprcpsp_REAL_NAME} PRIVATE
+	${PYTHON_INCLUDE_DIRS})
+target_link_libraries(${SWIG_MODULE_pywraprcpsp_REAL_NAME} PRIVATE
+	ortools::ortools ${PYTHON_LIBRARIES})
+if(UNIX)
+	if(NOT APPLE)
+		set_target_properties(${SWIG_MODULE_pywraprcpsp_REAL_NAME} PROPERTIES
+			INSTALL_RPATH "$ORIGIN/../../:$ORIGIN")
+	else()
+		set_target_properties(${SWIG_MODULE_pywraprcpsp_REAL_NAME} PROPERTIES
+			SUFFIX ".so"
+			INSTALL_RPATH	"@loader_path/../..:@loader_path")
+		set_property(TARGET ${SWIG_MODULE_pywraprcpsp_REAL_NAME} APPEND PROPERTY
+			LINK_FLAGS "-flat_namespace -undefined suppress")
+	endif()
+endif()

ortools/glop/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_glop)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_glop)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::glop ALIAS ${NAME})

ortools/graph/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_graph)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_graph)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::graph ALIAS ${NAME})

ortools/graph/python/CMakeLists.txt

@@ -1,9 +1,47 @@
-IF(BUILD_PYTHON)
-    SET_PROPERTY(SOURCE graph.i PROPERTY CPLUSPLUS ON)
-    SET_PROPERTY(SOURCE graph.i PROPERTY SWIG_MODULE_NAME pywrapgraph)
+# Setup SWIG
+find_package(SWIG REQUIRED)
+include(UseSWIG)
 
-    SWIG_ADD_LIBRARY(pywrapgraph TYPE MODULE LANGUAGE python SOURCES graph.i)
-    SWIG_LINK_LIBRARIES(pywrapgraph ${PROJECT_NAME})
+# Setup Python
+find_package(PythonInterp REQUIRED)
+find_package(PythonLibs REQUIRED)
 
-    INSTALL(TARGETS _pywrapgraph DESTINATION ${PYTHON_MODULE_PATH})
-ENDIF(BUILD_PYTHON)
+set_property(SOURCE graph.i PROPERTY CPLUSPLUS ON)
+list(APPEND CMAKE_SWIG_FLAGS "-module;pywrapgraph")
+
+# outdir for .py file
+set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/..)
+# outdir for .so file
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+# Second, for multi-config builds (e.g. msvc)
+foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+endforeach()
+
+if(${CMAKE_VERSION} VERSION_GREATER 3.8.2)
+	swig_add_library(pywrapgraph TYPE SHARED LANGUAGE python SOURCES graph.i)
+else()
+	swig_add_module(pywrapgraph python graph.i)
+endif()
+
+# ${SWIG_MODULE_<name>_REAL_NAME} will resolve to _<name>.so TARGET
+target_include_directories(${SWIG_MODULE_pywrapgraph_REAL_NAME} PRIVATE
+	${PYTHON_INCLUDE_DIRS})
+target_link_libraries(${SWIG_MODULE_pywrapgraph_REAL_NAME} PRIVATE
+	ortools::ortools ${PYTHON_LIBRARIES})
+if(UNIX)
+	if(NOT APPLE)
+		set_target_properties(${SWIG_MODULE_pywrapgraph_REAL_NAME} PROPERTIES
+			INSTALL_RPATH "$ORIGIN/../../:$ORIGIN")
+	else()
+		set_target_properties(${SWIG_MODULE_pywrapgraph_REAL_NAME} PROPERTIES
+			SUFFIX ".so"
+			INSTALL_RPATH	"@loader_path/../..:@loader_path")
+		set_property(TARGET ${SWIG_MODULE_pywrapgraph_REAL_NAME} APPEND PROPERTY
+			LINK_FLAGS "-flat_namespace -undefined suppress")
+	endif()
+endif()

ortools/linear_solver/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_linear_solver)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_linear_solver)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::linear_solver ALIAS ${NAME})

ortools/linear_solver/python/CMakeLists.txt

@@ -1,9 +1,46 @@
-IF(BUILD_PYTHON)
-    SET_PROPERTY(SOURCE linear_solver.i PROPERTY CPLUSPLUS ON)
-    SET_PROPERTY(SOURCE linear_solver.i PROPERTY SWIG_MODULE_NAME pywraplp)
+# Setup SWIG
+find_package(SWIG REQUIRED)
+include(UseSWIG)
 
-    SWIG_ADD_LIBRARY(pywraplp TYPE MODULE LANGUAGE python SOURCES linear_solver.i)
-    SWIG_LINK_LIBRARIES(pywraplp ${PROJECT_NAME})
+# Setup Python
+find_package(PythonInterp REQUIRED)
+find_package(PythonLibs REQUIRED)
 
-    INSTALL(TARGETS _pywraplp DESTINATION ${PYTHON_MODULE_PATH})
-ENDIF()
+set_property(SOURCE linear_solver.i PROPERTY CPLUSPLUS ON)
+list(APPEND CMAKE_SWIG_FLAGS "-module;pywraplp")
+# outdir for .py file
+set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/..)
+# outdir for .so file
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+# Second, for multi-config builds (e.g. msvc)
+foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+endforeach()
+
+if(${CMAKE_VERSION} VERSION_GREATER 3.8.2)
+	swig_add_library(pywraplp TYPE SHARED LANGUAGE python SOURCES linear_solver.i)
+else()
+	swig_add_module(pywraplp python linear_solver.i)
+endif()
+
+# ${SWIG_MODULE_<name>_REAL_NAME} will resolve to _<name>.so TARGET
+target_include_directories(${SWIG_MODULE_pywraplp_REAL_NAME} PRIVATE
+	${PYTHON_INCLUDE_DIRS})
+target_link_libraries(${SWIG_MODULE_pywraplp_REAL_NAME} PRIVATE
+	ortools::ortools ${PYTHON_LIBRARIES})
+if(UNIX)
+	if(NOT APPLE)
+		set_target_properties(${SWIG_MODULE_pywraplp_REAL_NAME} PROPERTIES
+			INSTALL_RPATH "$ORIGIN/../../:$ORIGIN")
+	else()
+		set_target_properties(${SWIG_MODULE_pywraplp_REAL_NAME} PROPERTIES
+			SUFFIX ".so"
+			INSTALL_RPATH	"@loader_path/../..:@loader_path")
+		set_property(TARGET ${SWIG_MODULE_pywraplp_REAL_NAME} APPEND PROPERTY
+			LINK_FLAGS "-flat_namespace -undefined suppress")
+	endif()
+endif()

ortools/lp_data/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_lp_data)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_lp_data)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::lp_data ALIAS ${NAME})

ortools/port/CMakeLists.txt

@@ -0,0 +1,42 @@
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_port)
+
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::port ALIAS ${NAME})

ortools/sat/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_sat)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_sat)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::sat ALIAS ${NAME})

ortools/sat/python/CMakeLists.txt

@@ -0,0 +1,47 @@
+# Setup SWIG
+find_package(SWIG REQUIRED)
+include(UseSWIG)
+
+# Setup Python
+find_package(PythonInterp REQUIRED)
+find_package(PythonLibs REQUIRED)
+
+set_property(SOURCE sat.i PROPERTY CPLUSPLUS ON)
+list(APPEND CMAKE_SWIG_FLAGS "-module;pywrapsat")
+
+# outdir for .py file
+set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/..)
+# outdir for .so file
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
+# Second, for multi-config builds (e.g. msvc)
+foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
+	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_CURRENT_BINARY_DIR}/..)
+endforeach()
+
+if(${CMAKE_VERSION} VERSION_GREATER 3.8.2)
+	swig_add_library(pywrapsat TYPE SHARED LANGUAGE python SOURCES sat.i)
+else()
+	swig_add_module(pywrapsat python sat.i)
+endif()
+
+# ${SWIG_MODULE_<name>_REAL_NAME} will resolve to _<name>.so TARGET
+target_include_directories(${SWIG_MODULE_pywrapsat_REAL_NAME} PRIVATE
+	${PYTHON_INCLUDE_DIRS})
+target_link_libraries(${SWIG_MODULE_pywrapsat_REAL_NAME} PRIVATE
+	ortools::ortools ${PYTHON_LIBRARIES})
+if(UNIX)
+	if(NOT APPLE)
+		set_target_properties(${SWIG_MODULE_pywrapsat_REAL_NAME} PROPERTIES
+			INSTALL_RPATH "$ORIGIN/../../:$ORIGIN")
+	else()
+		set_target_properties(${SWIG_MODULE_pywrapsat_REAL_NAME} PROPERTIES
+			SUFFIX ".so"
+			INSTALL_RPATH	"@loader_path/../..:@loader_path")
+		set_property(TARGET ${SWIG_MODULE_pywrapsat_REAL_NAME} APPEND PROPERTY
+			LINK_FLAGS "-flat_namespace -undefined suppress")
+	endif()
+endif()

ortools/util/CMakeLists.txt

@@ -1,10 +1,42 @@
-ENABLE_LANGUAGE(CXX)
-SET(ROOT_PROJECT ${PROJECT_NAME})
-PROJECT(${PROJECT_NAME}_util)
+file(GLOB _SRCS "*.h" "*.cc")
+set(NAME ${PROJECT_NAME}_util)
 
-FILE(GLOB ${PROJECT_NAME}_SOURCES "*.cc")
-
-ADD_LIBRARY(${PROJECT_NAME} OBJECT ${${PROJECT_NAME}_SOURCES})
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-ADD_DEPENDENCIES(${PROJECT_NAME} ${ROOT_PROJECT}Proto)
+# Will be merge in libortools.so
+#add_library(${NAME} STATIC ${_SRCS})
+add_library(${NAME} OBJECT ${_SRCS})
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD 11)
+set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+set_target_properties(${NAME} PROPERTIES CXX_EXTENSIONS OFF)
+set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${NAME} PRIVATE
+	${PROJECT_SOURCE_DIR}
+	${PROJECT_BINARY_DIR}
+	$<TARGET_PROPERTY:gflags,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_INCLUDE_DIRECTORIES>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_INCLUDE_DIRECTORIES>)
+target_compile_options(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_OPTIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_OPTIONS>
+	)
+target_compile_definitions(${NAME} PRIVATE
+	$<TARGET_PROPERTY:gflags,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:glog::glog,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:protobuf::libprotobuf,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:Cbc::Cbc,INTERFACE_COMPILE_DEFINITIONS>
+	$<TARGET_PROPERTY:${PROJECT_NAME}::proto,INTERFACE_COMPILE_DEFINITIONS>
+	)
+# CMakeError: Object library may not link to anything.
+#target_link_libraries(${NAME} PRIVATE
+#  protobuf::libprotobuf
+#  gflags
+#  glog::glog
+#  Cbc::Cbc
+#  ${PROJECT_NAME}::proto)
+add_dependencies(${NAME}
+	protobuf::libprotobuf gflags glog::glog Cbc::Cbc ${PROJECT_NAME}::proto)
+add_library(${PROJECT_NAME}::util ALIAS ${NAME})

patches/glog.patch

@@ -0,0 +1,12 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 87f867d..821c441 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -410,6 +410,7 @@ add_compile_options ($<$<BOOL:${HAVE_NO_UNNAMED_TYPE_TEMPLATE_ARGS}>:-Wno-unname
+ add_library (glog
+   ${GLOG_SRCS}
+ )
++add_library(glog::glog ALIAS glog)
+ 
+ set_target_properties (glog PROPERTIES POSITION_INDEPENDENT_CODE ON)
+ 

patches/glog_includedir_fix.patch

@@ -1,25 +0,0 @@
-From 00663891e82c32fc032ee93ab8718e32a7a643d2 Mon Sep 17 00:00:00 2001
-From: Amit Prakash Ambasta <amit.ambasta@delhivery.com>
-Date: Wed, 7 Jun 2017 19:37:49 +0530
-Subject: [PATCH] Patch to fix invalid includedir for try_compile
-
----
- cmake/DetermineGflagsNamespace.cmake | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/cmake/DetermineGflagsNamespace.cmake b/cmake/DetermineGflagsNamespace.cmake
-index e5e50cc..3a30df8 100755
---- a/cmake/DetermineGflagsNamespace.cmake
-+++ b/cmake/DetermineGflagsNamespace.cmake
-@@ -35,7 +35,7 @@ int main(int argc, char**argv)
-         "${CMAKE_BINARY_DIR}" "${_check_file}"
-         COMPILE_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}" -DGFLAGS_NAMESPACE=${_namespace}
-         LINK_LIBRARIES "${gflags_LIBRARIES}"
--        CMAKE_FLAGS -DINCLUDE_DIRECTORIES:STRING="${gflags_INCLUDE_DIR}"
-+        CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${gflags_INCLUDE_DIR}"
-         OUTPUT_VARIABLE OUTPUT)
- 
-       if (${VARIABLE})
--- 
-2.13.0
-

patches/protobuf.patch

@@ -0,0 +1,115 @@
+diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
+index f159f60e..0a690c8f 100644
+--- a/cmake/CMakeLists.txt
++++ b/cmake/CMakeLists.txt
+@@ -116,20 +116,6 @@ if (protobuf_BUILD_SHARED_LIBS)
+   set(protobuf_SHARED_OR_STATIC "SHARED")
+ else (protobuf_BUILD_SHARED_LIBS)
+   set(protobuf_SHARED_OR_STATIC "STATIC")
+-  # In case we are building static libraries, link also the runtime library statically
+-  # so that MSVCR*.DLL is not required at runtime.
+-  # https://msdn.microsoft.com/en-us/library/2kzt1wy3.aspx
+-  # This is achieved by replacing msvc option /MD with /MT and /MDd with /MTd
+-  # http://www.cmake.org/Wiki/CMake_FAQ#How_can_I_build_my_MSVC_application_with_a_static_runtime.3F
+-  if (MSVC AND protobuf_MSVC_STATIC_RUNTIME)
+-    foreach(flag_var
+-        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+-        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+-      if(${flag_var} MATCHES "/MD")
+-        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+-      endif(${flag_var} MATCHES "/MD")
+-    endforeach(flag_var)
+-  endif (MSVC AND protobuf_MSVC_STATIC_RUNTIME)
+ endif (protobuf_BUILD_SHARED_LIBS)
+ 
+ if (MSVC)
+@@ -157,7 +143,7 @@ if (MSVC)
+   string(REPLACE "/" "\\" PROTOBUF_SOURCE_WIN32_PATH ${protobuf_SOURCE_DIR})
+   string(REPLACE "/" "\\" PROTOBUF_BINARY_WIN32_PATH ${protobuf_BINARY_DIR})
+   configure_file(extract_includes.bat.in extract_includes.bat)
+-  
++
+   # Suppress linker warnings about files with no symbols defined.
+   set(CMAKE_STATIC_LINKER_FLAGS /ignore:4221)
+ endif (MSVC)
+diff --git a/cmake/install.cmake b/cmake/install.cmake
+index 441bf553..2e7695ec 100644
+--- a/cmake/install.cmake
++++ b/cmake/install.cmake
+@@ -100,22 +100,24 @@ configure_file(protobuf-module.cmake.in
+ configure_file(protobuf-options.cmake
+   ${CMAKE_INSTALL_CMAKEDIR}/protobuf-options.cmake @ONLY)
+ 
+-# Allows the build directory to be used as a find directory.
+-export(TARGETS libprotobuf-lite libprotobuf libprotoc protoc
+-  NAMESPACE protobuf::
+-  FILE ${CMAKE_INSTALL_CMAKEDIR}/protobuf-targets.cmake
+-)
++if ("^${CMAKE_SOURCE_DIR}$" STREQUAL "^${PROJECT_SOURCE_DIR}$")
++  # Allows the build directory to be used as a find directory.
++  export(TARGETS libprotobuf-lite libprotobuf libprotoc protoc
++    NAMESPACE protobuf::
++    FILE ${CMAKE_INSTALL_CMAKEDIR}/protobuf-targets.cmake
++  )
+ 
+-install(EXPORT protobuf-targets
+-  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
+-  NAMESPACE protobuf::
+-  COMPONENT protobuf-export)
++  install(EXPORT protobuf-targets
++    DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
++    NAMESPACE protobuf::
++    COMPONENT protobuf-export)
+ 
+-install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_CMAKEDIR}/
+-  DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
+-  COMPONENT protobuf-export
+-  PATTERN protobuf-targets.cmake EXCLUDE
+-)
++  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_CMAKEDIR}/
++    DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
++    COMPONENT protobuf-export
++    PATTERN protobuf-targets.cmake EXCLUDE
++  )
++endif()
+ 
+ option(protobuf_INSTALL_EXAMPLES "Install the examples folder" OFF)
+ if(protobuf_INSTALL_EXAMPLES)
+diff --git a/cmake/libprotobuf-lite.cmake b/cmake/libprotobuf-lite.cmake
+index 9e1fab0a..80ffff08 100644
+--- a/cmake/libprotobuf-lite.cmake
++++ b/cmake/libprotobuf-lite.cmake
+@@ -62,3 +62,4 @@ endif()
+ set_target_properties(libprotobuf-lite PROPERTIES
+     OUTPUT_NAME ${LIB_PREFIX}protobuf-lite
+     DEBUG_POSTFIX "${protobuf_DEBUG_POSTFIX}")
++add_library(protobuf::libprotobuf-lite ALIAS libprotobuf-lite)
+diff --git a/cmake/libprotobuf.cmake b/cmake/libprotobuf.cmake
+index 72db915b..e3b1d7a7 100644
+--- a/cmake/libprotobuf.cmake
++++ b/cmake/libprotobuf.cmake
+@@ -127,3 +127,6 @@ endif()
+ set_target_properties(libprotobuf PROPERTIES
+     OUTPUT_NAME ${LIB_PREFIX}protobuf
+     DEBUG_POSTFIX "${protobuf_DEBUG_POSTFIX}")
++add_library(protobuf::libprotobuf ALIAS libprotobuf)
++# CMake define findProtobuf which import protobuf::* targets
++add_library(Protobuf ALIAS libprotobuf)
+diff --git a/cmake/libprotoc.cmake b/cmake/libprotoc.cmake
+index 107c1c52..87d8b862 100644
+--- a/cmake/libprotoc.cmake
++++ b/cmake/libprotoc.cmake
+@@ -227,3 +227,4 @@ set_target_properties(libprotoc PROPERTIES
+     COMPILE_DEFINITIONS LIBPROTOC_EXPORTS
+     OUTPUT_NAME ${LIB_PREFIX}protoc
+     DEBUG_POSTFIX "${protobuf_DEBUG_POSTFIX}")
++add_library(protobuf::libprotoc ALIAS libprotoc)
+diff --git a/cmake/protoc.cmake b/cmake/protoc.cmake
+index 4f07c389..5777b16e 100644
+--- a/cmake/protoc.cmake
++++ b/cmake/protoc.cmake
+@@ -4,3 +4,4 @@ set(protoc_files
+ 
+ add_executable(protoc ${protoc_files})
+ target_link_libraries(protoc libprotobuf libprotoc)
++add_executable(protobuf::protoc ALIAS protoc)

patches/zlib.patch

@@ -0,0 +1,210 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 0fe939d..5f25cce 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -1,24 +1,23 @@
+-cmake_minimum_required(VERSION 2.4.4)
+-set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
++cmake_minimum_required(VERSION 2.8.12)
++cmake_policy(SET CMP0048 NEW)
++project(zlib VERSION 1.2.11.1 LANGUAGES C)
+ 
+-project(zlib C)
++option(ASM686 "Enable building i686 assembly implementation" OFF)
++option(AMD64 "Enable building amd64 assembly implementation" OFF)
+ 
+-set(VERSION "1.2.11")
++include(GNUInstallDirs)
++set(INSTALL_BIN_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH "Installation directory for executables")
++set(INSTALL_LIB_DIR "${CMAKE_INSTALL_LIBDIR}" CACHE PATH "Installation directory for libraries")
++set(INSTALL_INC_DIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE PATH "Installation directory for headers")
+ 
+-option(ASM686 "Enable building i686 assembly implementation")
+-option(AMD64 "Enable building amd64 assembly implementation")
+-
+-set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
+-set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
+-set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
+-set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
+-set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
++set(INSTALL_MAN_DIR "${CMAKE_INSTALL_MANDIR}" CACHE PATH "Installation directory for manual pages")
++set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_DATADIR}/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
+ 
+ include(CheckTypeSize)
+ include(CheckFunctionExists)
+ include(CheckIncludeFile)
+ include(CheckCSourceCompiles)
+-enable_testing()
++include(CTest)
+ 
+ check_include_file(sys/types.h HAVE_SYS_TYPES_H)
+ check_include_file(stdint.h    HAVE_STDINT_H)
+@@ -63,7 +62,6 @@ if(MSVC)
+     set(CMAKE_DEBUG_POSTFIX "d")
+     add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+     add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+-    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+ endif()
+ 
+ if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+@@ -83,7 +81,6 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein
+ 		${ZLIB_PC} @ONLY)
+ configure_file(	${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein
+ 		${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
+-include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR})
+ 
+ 
+ #============================================================================
+@@ -132,9 +129,9 @@ endif()
+ if(CMAKE_COMPILER_IS_GNUCC)
+     if(ASM686)
+         set(ZLIB_ASMS contrib/asm686/match.S)
+-    elseif (AMD64)
++			elseif(AMD64)
+         set(ZLIB_ASMS contrib/amd64/amd64-match.S)
+-    endif ()
++    endif()
+ 
+ 	if(ZLIB_ASMS)
+ 		add_definitions(-DASMV)
+@@ -143,20 +140,20 @@ if(CMAKE_COMPILER_IS_GNUCC)
+ endif()
+ 
+ if(MSVC)
+-    if(ASM686)
++	if(ASM686)
+ 		ENABLE_LANGUAGE(ASM_MASM)
+-        set(ZLIB_ASMS
++		set(ZLIB_ASMS
+ 			contrib/masmx86/inffas32.asm
+ 			contrib/masmx86/match686.asm
+-		)
+-    elseif (AMD64)
++			)
++	elseif(AMD64)
+ 		ENABLE_LANGUAGE(ASM_MASM)
+-        set(ZLIB_ASMS
++		set(ZLIB_ASMS
+ 			contrib/masmx64/gvmat64.asm
+ 			contrib/masmx64/inffasx64.asm
+-		)
+-    endif()
+-
++			)
++		# set(ZLIB_SRCS ${ZLIB_SRCS} contrib/masmx64/inffas8664.c)
++	endif()
+ 	if(ZLIB_ASMS)
+ 		add_definitions(-DASMV -DASMINF)
+ 	endif()
+@@ -184,9 +181,25 @@ if(MINGW)
+ endif(MINGW)
+ 
+ add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
++target_include_directories(zlib PUBLIC
++	$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
++	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
++	$<INSTALL_INTERFACE:include>)
++set_target_properties(zlib PROPERTIES
++	DEFINE_SYMBOL ZLIB_DLL
++	SOVERSION 1)
++
+ add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
+-set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
+-set_target_properties(zlib PROPERTIES SOVERSION 1)
++target_include_directories(zlibstatic PUBLIC
++	$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
++	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
++	$<INSTALL_INTERFACE:include>)
++
++if(BUILD_SHARED_LIBS)
++	add_library(ZLIB::ZLIB ALIAS zlib)
++else()
++	add_library(ZLIB::ZLIB ALIAS zlibstatic)
++endif()
+ 
+ if(NOT CYGWIN)
+     # This property causes shared libraries on Linux to have the full version
+@@ -197,6 +210,7 @@ if(NOT CYGWIN)
+     # This has no effect with MSVC, on that platform the version info for
+     # the DLL comes from the resource file win32/zlib1.rc
+     set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})
++    set_target_properties(zlibstatic PROPERTIES VERSION ${ZLIB_FULL_VERSION})
+ endif()
+ 
+ if(UNIX)
+@@ -210,12 +224,30 @@ elseif(BUILD_SHARED_LIBS AND WIN32)
+     set_target_properties(zlib PROPERTIES SUFFIX "1.dll")
+ endif()
+ 
+-if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
++#if(WIN32)
++#	add_definitions(-DZLIB_WINAPI)
++#endif()
++
++if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL)
+     install(TARGETS zlib zlibstatic
+-        RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
+-        ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
+-        LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
+-endif()
++			EXPORT ZLIBTargets
++			RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
++			ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
++			LIBRARY DESTINATION "${INSTALL_LIB_DIR}")
++		install(EXPORT ZLIBTargets
++			NAMESPACE ZLIB::
++			DESTINATION lib/cmake/ZLIB)
++		include(CMakePackageConfigHelpers)
++		write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/ZLIBConfigVersion.cmake"
++			VERSION ${PROJECT_VERSION}
++			COMPATIBILITY SameMajorVersion)
++		file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/ZLIBConfig.cmake"
++			"include(\"\${CMAKE_CURRENT_LIST_DIR}/ZLIBTargets.cmake\")"
++			)
++		install(FILES "${CMAKE_CURRENT_BINARY_DIR}/ZLIBConfig.cmake"
++			"${CMAKE_CURRENT_BINARY_DIR}/ZLIBConfigVersion.cmake"
++			DESTINATION lib/cmake/ZLIB)
++	endif()
+ if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
+     install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
+ endif()
+@@ -229,21 +261,22 @@ endif()
+ #============================================================================
+ # Example binaries
+ #============================================================================
+-
+-add_executable(example test/example.c)
+-target_link_libraries(example zlib)
+-add_test(example example)
+-
+-add_executable(minigzip test/minigzip.c)
+-target_link_libraries(minigzip zlib)
+-
+-if(HAVE_OFF64_T)
+-    add_executable(example64 test/example.c)
+-    target_link_libraries(example64 zlib)
+-    set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
+-    add_test(example64 example64)
+-
+-    add_executable(minigzip64 test/minigzip.c)
+-    target_link_libraries(minigzip64 zlib)
+-    set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
++if(BUILD_TESTING)
++	add_executable(example test/example.c)
++	target_link_libraries(example zlib)
++	add_test(example example)
++
++	add_executable(minigzip test/minigzip.c)
++	target_link_libraries(minigzip zlib)
++
++	if(HAVE_OFF64_T)
++		add_executable(example64 test/example.c)
++		target_link_libraries(example64 zlib)
++		set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
++		add_test(example64 example64)
++
++		add_executable(minigzip64 test/minigzip.c)
++		target_link_libraries(minigzip64 zlib)
++		set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
++	endif()
+ endif()

python/MANIFEST.in

@@ -1 +0,0 @@
-recursive-include ortools *.i

python/setup.py.in

@@ -1,104 +0,0 @@
-import os
-from setuptools import setup, find_packages, Extension
-from distutils.command.build import build as _build
-
-class build(_build):
-    sub_commands = [
-        ('build_ext', _build.has_ext_modules),
-        ('build_py', _build.has_pure_modules),
-        ('build_clib', _build.has_c_libraries),
-        ('build_scripts', _build.has_scripts)]
-
-
-SWIG_CXX_OPTS = "${CMAKE_SWIG_FLAGS}"
-PROJ_INC_DIRS = ".;/usr/include;/usr/local/include"
-MODULE_MAP = {
-    'pywrapcp': 'ortools/constraint_solver/python/routing.i',
-    'pywrapknapsack_solver': 'ortools/algorithms/python/knapsack_solver.i',
-    'pywrapgraph': 'ortools/graph/python/graph.i',
-    'pywraplp': 'ortools/linear_solver/python/linear_solver.i'
-}
-
-
-def split_cmake_list(lst, prefix=None):
-    lst_ = lst.strip().split(';')
-
-    if prefix is None:
-        return lst_
-
-    _lst = []
-    for item in lst_:
-        _lst.append('{}{}'.format(prefix, item))
-    return _lst
-
-
-def get_outdir(_file):
-    if 'python' in _file:
-        return _file.split('python')[0]
-    return '/'.join(_file.split('/')[:-1])
-
-extensions = []
-for module, _file in MODULE_MAP.items():
-    ext = Extension(
-        '_{}'.format(module),
-        [_file],
-        swig_opts=split_cmake_list(SWIG_CXX_OPTS) + [
-            '-c++', '-I.', '-module', module] + split_cmake_list(
-            PROJ_INC_DIRS, '-I') + [
-            '-outdir', get_outdir(_file)],
-        include_dirs=split_cmake_list(PROJ_INC_DIRS),
-        libraries=['${PROJECT_NAME}'],
-        extra_compile_args="${CMAKE_CXX_FLAGS}".strip().split(' ')
-    )
-    extensions.append(ext)
-
-modules = []
-for module, _file in MODULE_MAP.items():
-    _path = os.path.dirname(_file)
-    _path = _path.split('python')[0]
-    _path = _path.split('/')
-
-    lst = []
-    for __path in _path:
-        if __path:
-            lst.append(__path)
-    lst.append(module)
-    modules.append('.'.join(lst))
-
-
-with open('${README_FILE}') as f:
-    long_description = f.read()
-
-setup(
-    name="${PROJECT_NAME}",
-    cmdclass={'build': build},
-    version="${PROJECT_VERSION}",
-    description="Google OR-Tools python libraries and modules",
-    long_description=long_description,
-    url='https://developers.google.com/optimization/',
-    author='${AUTHORS}',
-    author_email='${AUTHOR_EMAIL}',
-    license='${LICENSE}',
-    keywords = (
-        'operations research, constraint programming, linear programming, '
-        'flow algorithms, python'),
-    classifiers = [
-        'Development Status :: 5 - Production/Stable',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: Apache Software License',
-        'Operating System :: MacOS :: MacOS X',
-        'Operating System :: Microsoft :: Windows',
-        'Operating System :: POSIX :: Linux',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Topic :: Office/Business :: Scheduling',
-        'Topic :: Scientific/Engineering',
-        'Topic :: Scientific/Engineering :: Mathematics',
-        'Topic :: Software Development :: Libraries :: Python Modules'],
-    packages=find_packages(),
-    ext_modules=extensions,
-    py_modules=modules,
-)