]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
1 | # Licensed to the Apache Software Foundation (ASF) under one |
2 | # or more contributor license agreements. See the NOTICE file | |
3 | # distributed with this work for additional information | |
4 | # regarding copyright ownership. The ASF licenses this file | |
5 | # to you under the Apache License, Version 2.0 (the | |
6 | # "License"); you may not use this file except in compliance | |
7 | # with the License. You may obtain a copy of the License at | |
8 | # | |
9 | # http://www.apache.org/licenses/LICENSE-2.0 | |
10 | # | |
11 | # Unless required by applicable law or agreed to in writing, | |
12 | # software distributed under the License is distributed on an | |
13 | # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
14 | # KIND, either express or implied. See the License for the | |
15 | # specific language governing permissions and limitations | |
16 | # under the License. | |
17 | ||
18 | cmake_minimum_required(VERSION 3.20) | |
19 | ||
20 | # Build the Arrow C++ libraries. | |
21 | function(build_arrow) | |
22 | set(options BUILD_GTEST) | |
23 | set(one_value_args) | |
24 | set(multi_value_args) | |
25 | cmake_parse_arguments(ARG | |
26 | "${options}" | |
27 | "${one_value_args}" | |
28 | "${multi_value_args}" | |
29 | ${ARGN}) | |
30 | if(ARG_UNPARSED_ARGUMENTS) | |
31 | message(SEND_ERROR "Error: unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}") | |
32 | endif() | |
33 | ||
34 | if(WIN32) | |
35 | set(ARROW_IMPORTED_TYPE IMPORTED_IMPLIB) | |
36 | set(ARROW_LIBRARY_SUFFIX ${CMAKE_IMPORT_LIBRARY_SUFFIX}) | |
37 | else() | |
38 | set(ARROW_IMPORTED_TYPE IMPORTED_LOCATION) | |
39 | set(ARROW_LIBRARY_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}) | |
40 | endif() | |
41 | ||
42 | set(ARROW_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep-prefix") | |
43 | set(ARROW_INCLUDE_DIR "${ARROW_PREFIX}/include") | |
44 | set(ARROW_LIBRARY_DIR "${ARROW_PREFIX}/lib") | |
45 | set(ARROW_SHARED_LIB | |
46 | "${ARROW_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}arrow${ARROW_LIBRARY_SUFFIX}") | |
47 | set(ARROW_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep-build") | |
48 | set(ARROW_CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}" | |
49 | "-DCMAKE_INSTALL_LIBDIR=lib" "-DARROW_BUILD_STATIC=OFF") | |
50 | set(ARROW_BUILD_BYPRODUCTS "${ARROW_SHARED_LIB}") | |
51 | ||
52 | # Building the Arrow C++ libraries and bundled GoogleTest binaries requires ExternalProject. | |
53 | include(ExternalProject) | |
54 | ||
55 | if(ARG_BUILD_GTEST) | |
56 | enable_gtest() | |
57 | endif() | |
58 | ||
59 | externalproject_add(arrow_ep | |
60 | SOURCE_DIR "${CMAKE_SOURCE_DIR}/../cpp" | |
61 | BINARY_DIR "${ARROW_BINARY_DIR}" | |
62 | CMAKE_ARGS ${ARROW_CMAKE_ARGS} | |
63 | BUILD_BYPRODUCTS ${ARROW_BUILD_BYPRODUCTS}) | |
64 | ||
65 | set(ARROW_LIBRARY_TARGET arrow_shared) | |
66 | ||
67 | # If find_package has already found a valid Arrow installation, then | |
68 | # we don't want to link against the newly built arrow_shared library. | |
69 | # However, we still need create a library target to trigger building | |
70 | # of the arrow_ep target, which will ultimately build the bundled | |
71 | # GoogleTest binaries. | |
72 | if(Arrow_FOUND) | |
73 | set(ARROW_LIBRARY_TARGET arrow_shared_for_gtest) | |
74 | endif() | |
75 | ||
76 | file(MAKE_DIRECTORY "${ARROW_INCLUDE_DIR}") | |
77 | add_library(${ARROW_LIBRARY_TARGET} SHARED IMPORTED) | |
78 | set_target_properties(${ARROW_LIBRARY_TARGET} | |
79 | PROPERTIES ${ARROW_IMPORTED_TYPE} ${ARROW_SHARED_LIB} | |
80 | INTERFACE_INCLUDE_DIRECTORIES ${ARROW_INCLUDE_DIR}) | |
81 | ||
82 | add_dependencies(${ARROW_LIBRARY_TARGET} arrow_ep) | |
83 | ||
84 | if(ARG_BUILD_GTEST) | |
85 | build_gtest() | |
86 | endif() | |
87 | ||
88 | endfunction() | |
89 | ||
90 | macro(enable_gtest) | |
91 | if(WIN32) | |
92 | set(ARROW_GTEST_IMPORTED_TYPE IMPORTED_IMPLIB) | |
93 | set(ARROW_GTEST_MAIN_IMPORTED_TYPE IMPORTED_IMPLIB) | |
94 | ||
95 | set(ARROW_GTEST_LIBRARY_SUFFIX ${CMAKE_IMPORT_LIBRARY_SUFFIX}) | |
96 | set(ARROW_GTEST_MAIN_LIBRARY_SUFFIX ${CMAKE_IMPORT_LIBRARY_SUFFIX}) | |
97 | else() | |
98 | set(ARROW_GTEST_IMPORTED_TYPE IMPORTED_LOCATION) | |
99 | set(ARROW_GTEST_MAIN_IMPORTED_TYPE IMPORTED_LOCATION) | |
100 | ||
101 | set(ARROW_GTEST_LIBRARY_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}) | |
102 | set(ARROW_GTEST_MAIN_LIBRARY_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}) | |
103 | endif() | |
104 | ||
105 | set(ARROW_GTEST_PREFIX "${ARROW_BINARY_DIR}/googletest_ep-prefix") | |
106 | set(ARROW_GTEST_INCLUDE_DIR "${ARROW_GTEST_PREFIX}/include") | |
107 | set(ARROW_GTEST_LIBRARY_DIR "${ARROW_GTEST_PREFIX}/lib") | |
108 | set(ARROW_GTEST_SHARED_LIB | |
109 | "${ARROW_GTEST_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest${ARROW_GTEST_LIBRARY_SUFFIX}" | |
110 | ) | |
111 | ||
112 | set(ARROW_GTEST_MAIN_PREFIX "${ARROW_BINARY_DIR}/googletest_ep-prefix") | |
113 | set(ARROW_GTEST_MAIN_INCLUDE_DIR "${ARROW_GTEST_MAIN_PREFIX}/include") | |
114 | set(ARROW_GTEST_MAIN_LIBRARY_DIR "${ARROW_GTEST_MAIN_PREFIX}/lib") | |
115 | set(ARROW_GTEST_MAIN_SHARED_LIB | |
116 | "${ARROW_GTEST_MAIN_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest_main${ARROW_GTEST_MAIN_LIBRARY_SUFFIX}" | |
117 | ) | |
118 | ||
119 | list(APPEND ARROW_CMAKE_ARGS "-DARROW_BUILD_TESTS=ON") | |
120 | list(APPEND ARROW_BUILD_BYPRODUCTS "${ARROW_GTEST_SHARED_LIB}" | |
121 | "${ARROW_GTEST_MAIN_SHARED_LIB}") | |
122 | endmacro() | |
123 | ||
124 | # Build the GoogleTest binaries that are bundled with the Arrow C++ libraries. | |
125 | macro(build_gtest) | |
126 | set(ARROW_GTEST_INCLUDE_DIR "${ARROW_GTEST_PREFIX}/include") | |
127 | set(ARROW_GTEST_MAIN_INCLUDE_DIR "${ARROW_GTEST_MAIN_PREFIX}/include") | |
128 | ||
129 | file(MAKE_DIRECTORY "${ARROW_GTEST_INCLUDE_DIR}") | |
130 | ||
131 | if(WIN32) | |
132 | set(ARROW_GTEST_RUNTIME_DIR "${ARROW_GTEST_PREFIX}/bin") | |
133 | set(ARROW_GTEST_MAIN_RUNTIME_DIR "${ARROW_GTEST_MAIN_PREFIX}/bin") | |
134 | set(ARROW_GTEST_RUNTIME_SUFFIX "${CMAKE_SHARED_LIBRARY_SUFFIX}") | |
135 | set(ARROW_GTEST_MAIN_RUNTIME_SUFFIX "${CMAKE_SHARED_LIBRARY_SUFFIX}") | |
136 | set(ARROW_GTEST_RUNTIME_LIB | |
137 | "${ARROW_GTEST_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest${ARROW_GTEST_RUNTIME_SUFFIX}" | |
138 | ) | |
139 | set(ARROW_GTEST_MAIN_RUNTIME_LIB | |
140 | "${ARROW_GTEST_MAIN_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest_main${ARROW_GTEST_MAIN_RUNTIME_SUFFIX}" | |
141 | ) | |
142 | ||
143 | # Multi-Configuration generators (e.g. Visual Studio or XCode) place their build artifacts | |
144 | # in a subdirectory named ${CMAKE_BUILD_TYPE} by default, where ${CMAKE_BUILD_TYPE} varies | |
145 | # depending on the chosen build configuration (e.g. Release or Debug). | |
146 | get_property(GENERATOR_IS_MULTI_CONFIG_VALUE GLOBAL | |
147 | PROPERTY GENERATOR_IS_MULTI_CONFIG) | |
148 | if(GENERATOR_IS_MULTI_CONFIG_VALUE) | |
149 | set(MATLAB_TESTS_DIR "${CMAKE_BINARY_DIR}/$<CONFIG>") | |
150 | else() | |
151 | set(MATLAB_TESTS_DIR "${CMAKE_BINARY_DIR}") | |
152 | endif() | |
153 | ||
154 | # We need to copy the gtest and gtest_main runtime DLLs into the directory where the | |
155 | # MATLAB C++ tests reside, since Windows requires that runtime DLLs are in the same | |
156 | # directory as the executables that depend on them (or on the %PATH%). | |
157 | externalproject_add_step(arrow_ep copy | |
158 | COMMAND ${CMAKE_COMMAND} -E make_directory | |
159 | ${MATLAB_TESTS_DIR} | |
160 | COMMAND ${CMAKE_COMMAND} -E copy ${ARROW_GTEST_RUNTIME_LIB} | |
161 | ${MATLAB_TESTS_DIR} | |
162 | COMMAND ${CMAKE_COMMAND} -E copy | |
163 | ${ARROW_GTEST_MAIN_RUNTIME_LIB} ${MATLAB_TESTS_DIR} | |
164 | DEPENDEES install) | |
165 | endif() | |
166 | ||
167 | add_library(GTest::gtest SHARED IMPORTED) | |
168 | set_target_properties(GTest::gtest | |
169 | PROPERTIES ${ARROW_GTEST_IMPORTED_TYPE} ${ARROW_GTEST_SHARED_LIB} | |
170 | INTERFACE_INCLUDE_DIRECTORIES | |
171 | ${ARROW_GTEST_INCLUDE_DIR}) | |
172 | ||
173 | add_library(GTest::gtest_main SHARED IMPORTED) | |
174 | set_target_properties(GTest::gtest_main | |
175 | PROPERTIES ${ARROW_GTEST_MAIN_IMPORTED_TYPE} | |
176 | ${ARROW_GTEST_MAIN_SHARED_LIB} | |
177 | INTERFACE_INCLUDE_DIRECTORIES | |
178 | ${ARROW_GTEST_MAIN_INCLUDE_DIR}) | |
179 | ||
180 | add_dependencies(GTest::gtest arrow_ep) | |
181 | add_dependencies(GTest::gtest_main arrow_ep) | |
182 | endmacro() | |
183 | ||
184 | set(CMAKE_CXX_STANDARD 11) | |
185 | ||
186 | set(MLARROW_VERSION "6.0.1") | |
187 | string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" MLARROW_BASE_VERSION "${MLARROW_VERSION}") | |
188 | ||
189 | project(mlarrow VERSION "${MLARROW_BASE_VERSION}") | |
190 | ||
191 | option(MATLAB_BUILD_TESTS "Build the C++ tests for the MATLAB interface" OFF) | |
192 | ||
193 | # Grab CMAKE Modules from the CPP interface | |
194 | set(CPP_CMAKE_MODULES "${CMAKE_SOURCE_DIR}/../cpp/cmake_modules") | |
195 | if(EXISTS "${CPP_CMAKE_MODULES}") | |
196 | set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CPP_CMAKE_MODULES}) | |
197 | endif() | |
198 | ||
199 | set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake_modules) | |
200 | ||
201 | # Only build the MATLAB interface C++ tests if MATLAB_BUILD_TESTS=ON. | |
202 | if(MATLAB_BUILD_TESTS) | |
203 | # find_package(GTest) supports custom GTEST_ROOT as well as package managers. | |
204 | find_package(GTest) | |
205 | if(NOT GTest_FOUND) | |
206 | # find_package(Arrow) supports custom ARROW_HOME as well as package | |
207 | # managers. | |
208 | find_package(Arrow) | |
209 | # Trigger an automatic build of the Arrow C++ libraries and bundled | |
210 | # GoogleTest binaries. If a valid Arrow installation was not already | |
211 | # found by find_package, then build_arrow will use the Arrow | |
212 | # C++ libraries that are built from source. | |
213 | build_arrow(BUILD_GTEST) | |
214 | else() | |
215 | find_package(Arrow) | |
216 | if(NOT Arrow_FOUND) | |
217 | # Trigger an automatic build of the Arrow C++ libraries. | |
218 | build_arrow() | |
219 | endif() | |
220 | endif() | |
221 | else() | |
222 | find_package(Arrow) | |
223 | if(NOT Arrow_FOUND) | |
224 | build_arrow() | |
225 | endif() | |
226 | endif() | |
227 | ||
228 | # MATLAB is Required | |
229 | find_package(Matlab REQUIRED) | |
230 | ||
231 | # Construct the absolute path to featherread's source files | |
232 | set(featherread_sources featherreadmex.cc feather_reader.cc util/handle_status.cc | |
233 | util/unicode_conversion.cc) | |
234 | list(TRANSFORM featherread_sources PREPEND ${CMAKE_SOURCE_DIR}/src/) | |
235 | ||
236 | # Build featherreadmex MEX binary | |
237 | matlab_add_mex(R2018a | |
238 | NAME featherreadmex | |
239 | SRC ${featherread_sources} | |
240 | LINK_TO arrow_shared) | |
241 | ||
242 | # Construct the absolute path to featherwrite's source files | |
243 | set(featherwrite_sources featherwritemex.cc feather_writer.cc util/handle_status.cc | |
244 | util/unicode_conversion.cc) | |
245 | list(TRANSFORM featherwrite_sources PREPEND ${CMAKE_SOURCE_DIR}/src/) | |
246 | ||
247 | # Build featherwritemex MEX binary | |
248 | matlab_add_mex(R2018a | |
249 | NAME featherwritemex | |
250 | SRC ${featherwrite_sources} | |
251 | LINK_TO arrow_shared) | |
252 | ||
253 | # Ensure the MEX binaries are placed in the src directory on all platforms | |
254 | if(WIN32) | |
255 | set_target_properties(featherreadmex PROPERTIES RUNTIME_OUTPUT_DIRECTORY | |
256 | $<1:${CMAKE_SOURCE_DIR}/src>) | |
257 | set_target_properties(featherwritemex PROPERTIES RUNTIME_OUTPUT_DIRECTORY | |
258 | $<1:${CMAKE_SOURCE_DIR}/src>) | |
259 | else() | |
260 | set_target_properties(featherreadmex PROPERTIES LIBRARY_OUTPUT_DIRECTORY | |
261 | $<1:${CMAKE_SOURCE_DIR}/src>) | |
262 | set_target_properties(featherwritemex PROPERTIES LIBRARY_OUTPUT_DIRECTORY | |
263 | $<1:${CMAKE_SOURCE_DIR}/src>) | |
264 | endif() | |
265 | ||
266 | # ############################################################################## | |
267 | # C++ Tests | |
268 | # ############################################################################## | |
269 | # Only build the C++ tests if MATLAB_BUILD_TESTS=ON. | |
270 | if(MATLAB_BUILD_TESTS) | |
271 | enable_testing() | |
272 | ||
273 | # Define a test executable target. TODO: Remove the placeholder test. This is | |
274 | # just for testing GoogleTest integration. | |
275 | add_executable(placeholder_test ${CMAKE_SOURCE_DIR}/src/placeholder_test.cc) | |
276 | # Declare a dependency on the GTest::gtest and GTest::gtest_main IMPORTED | |
277 | # targets. | |
278 | target_link_libraries(placeholder_test GTest::gtest GTest::gtest_main) | |
279 | ||
280 | # Add a test target. | |
281 | add_test(PlaceholderTestTarget placeholder_test) | |
282 | endif() |