--- /dev/null
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# - Find Arrow (arrow/api.h, libarrow.a, libarrow.so)
+# This module defines
+# ARROW_FOUND, whether Arrow has been found
+# ARROW_FULL_SO_VERSION, full shared object version of found Arrow "100.0.0"
+# ARROW_IMPORT_LIB, path to libarrow's import library (Windows only)
+# ARROW_INCLUDE_DIR, directory containing headers
+# ARROW_LIBS, deprecated. Use ARROW_LIB_DIR instead
+# ARROW_LIB_DIR, directory containing Arrow libraries
+# ARROW_SHARED_IMP_LIB, deprecated. Use ARROW_IMPORT_LIB instead
+# ARROW_SHARED_LIB, path to libarrow's shared library
+# ARROW_SO_VERSION, shared object version of found Arrow such as "100"
+# ARROW_STATIC_LIB, path to libarrow.a
+# ARROW_VERSION, version of found Arrow
+# ARROW_VERSION_MAJOR, major version of found Arrow
+# ARROW_VERSION_MINOR, minor version of found Arrow
+# ARROW_VERSION_PATCH, patch version of found Arrow
+
+if(DEFINED ARROW_FOUND)
+ return()
+endif()
+
+include(FindPkgConfig)
+include(FindPackageHandleStandardArgs)
+
+if(WIN32 AND NOT MINGW)
+ # This is used to handle builds using e.g. clang in an MSVC setting.
+ set(MSVC_TOOLCHAIN TRUE)
+else()
+ set(MSVC_TOOLCHAIN FALSE)
+endif()
+
+set(ARROW_SEARCH_LIB_PATH_SUFFIXES)
+if(CMAKE_LIBRARY_ARCHITECTURE)
+ list(APPEND ARROW_SEARCH_LIB_PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+endif()
+list(APPEND
+ ARROW_SEARCH_LIB_PATH_SUFFIXES
+ "lib64"
+ "lib32"
+ "lib"
+ "bin")
+set(ARROW_CONFIG_SUFFIXES
+ "_RELEASE"
+ "_RELWITHDEBINFO"
+ "_MINSIZEREL"
+ "_DEBUG"
+ "")
+if(CMAKE_BUILD_TYPE)
+ string(TOUPPER ${CMAKE_BUILD_TYPE} ARROW_CONFIG_SUFFIX_PREFERRED)
+ set(ARROW_CONFIG_SUFFIX_PREFERRED "_${ARROW_CONFIG_SUFFIX_PREFERRED}")
+ list(INSERT ARROW_CONFIG_SUFFIXES 0 "${ARROW_CONFIG_SUFFIX_PREFERRED}")
+endif()
+
+if(NOT DEFINED ARROW_MSVC_STATIC_LIB_SUFFIX)
+ if(MSVC_TOOLCHAIN)
+ set(ARROW_MSVC_STATIC_LIB_SUFFIX "_static")
+ else()
+ set(ARROW_MSVC_STATIC_LIB_SUFFIX "")
+ endif()
+endif()
+
+# Internal function.
+#
+# Set shared library name for ${base_name} to ${output_variable}.
+#
+# Example:
+# arrow_build_shared_library_name(ARROW_SHARED_LIBRARY_NAME arrow)
+# # -> ARROW_SHARED_LIBRARY_NAME=libarrow.so on Linux
+# # -> ARROW_SHARED_LIBRARY_NAME=libarrow.dylib on macOS
+# # -> ARROW_SHARED_LIBRARY_NAME=arrow.dll with MSVC on Windows
+# # -> ARROW_SHARED_LIBRARY_NAME=libarrow.dll with MinGW on Windows
+function(arrow_build_shared_library_name output_variable base_name)
+ set(${output_variable}
+ "${CMAKE_SHARED_LIBRARY_PREFIX}${base_name}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+ PARENT_SCOPE)
+endfunction()
+
+# Internal function.
+#
+# Set import library name for ${base_name} to ${output_variable}.
+# This is useful only for MSVC build. Import library is used only
+# with MSVC build.
+#
+# Example:
+# arrow_build_import_library_name(ARROW_IMPORT_LIBRARY_NAME arrow)
+# # -> ARROW_IMPORT_LIBRARY_NAME=arrow on Linux (meaningless)
+# # -> ARROW_IMPORT_LIBRARY_NAME=arrow on macOS (meaningless)
+# # -> ARROW_IMPORT_LIBRARY_NAME=arrow.lib with MSVC on Windows
+# # -> ARROW_IMPORT_LIBRARY_NAME=libarrow.dll.a with MinGW on Windows
+function(arrow_build_import_library_name output_variable base_name)
+ set(${output_variable}
+ "${CMAKE_IMPORT_LIBRARY_PREFIX}${base_name}${CMAKE_IMPORT_LIBRARY_SUFFIX}"
+ PARENT_SCOPE)
+endfunction()
+
+# Internal function.
+#
+# Set static library name for ${base_name} to ${output_variable}.
+#
+# Example:
+# arrow_build_static_library_name(ARROW_STATIC_LIBRARY_NAME arrow)
+# # -> ARROW_STATIC_LIBRARY_NAME=libarrow.a on Linux
+# # -> ARROW_STATIC_LIBRARY_NAME=libarrow.a on macOS
+# # -> ARROW_STATIC_LIBRARY_NAME=arrow.lib with MSVC on Windows
+# # -> ARROW_STATIC_LIBRARY_NAME=libarrow.dll.a with MinGW on Windows
+function(arrow_build_static_library_name output_variable base_name)
+ set(${output_variable}
+ "${CMAKE_STATIC_LIBRARY_PREFIX}${base_name}${ARROW_MSVC_STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+ PARENT_SCOPE)
+endfunction()
+
+# Internal function.
+#
+# Set macro value for ${macro_name} in ${header_content} to ${output_variable}.
+#
+# Example:
+# arrow_extract_macro_value(version_major
+# "ARROW_VERSION_MAJOR"
+# "#define ARROW_VERSION_MAJOR 1.0.0")
+# # -> version_major=1.0.0
+function(arrow_extract_macro_value output_variable macro_name header_content)
+ string(REGEX MATCH "#define +${macro_name} +[^\r\n]+" macro_definition
+ "${header_content}")
+ string(REGEX REPLACE "^#define +${macro_name} +(.+)$" "\\1" macro_value
+ "${macro_definition}")
+ set(${output_variable}
+ "${macro_value}"
+ PARENT_SCOPE)
+endfunction()
+
+# Internal macro only for arrow_find_package.
+#
+# Find package in HOME.
+macro(arrow_find_package_home)
+ find_path(${prefix}_include_dir "${header_path}"
+ PATHS "${home}"
+ PATH_SUFFIXES "include"
+ NO_DEFAULT_PATH)
+ set(include_dir "${${prefix}_include_dir}")
+ set(${prefix}_INCLUDE_DIR
+ "${include_dir}"
+ PARENT_SCOPE)
+
+ if(MSVC_TOOLCHAIN)
+ set(CMAKE_SHARED_LIBRARY_SUFFIXES_ORIGINAL ${CMAKE_FIND_LIBRARY_SUFFIXES})
+ # .dll isn't found by find_library with MSVC because .dll isn't included in
+ # CMAKE_FIND_LIBRARY_SUFFIXES.
+ list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+ endif()
+ find_library(${prefix}_shared_lib
+ NAMES "${shared_lib_name}"
+ PATHS "${home}"
+ PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
+ NO_DEFAULT_PATH)
+ if(MSVC_TOOLCHAIN)
+ set(CMAKE_SHARED_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_ORIGINAL})
+ endif()
+ set(shared_lib "${${prefix}_shared_lib}")
+ set(${prefix}_SHARED_LIB
+ "${shared_lib}"
+ PARENT_SCOPE)
+ if(shared_lib)
+ add_library(${target_shared} SHARED IMPORTED)
+ set_target_properties(${target_shared} PROPERTIES IMPORTED_LOCATION "${shared_lib}")
+ if(include_dir)
+ set_target_properties(${target_shared} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+ "${include_dir}")
+ endif()
+ find_library(${prefix}_import_lib
+ NAMES "${import_lib_name}"
+ PATHS "${home}"
+ PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
+ NO_DEFAULT_PATH)
+ set(import_lib "${${prefix}_import_lib}")
+ set(${prefix}_IMPORT_LIB
+ "${import_lib}"
+ PARENT_SCOPE)
+ if(import_lib)
+ set_target_properties(${target_shared} PROPERTIES IMPORTED_IMPLIB "${import_lib}")
+ endif()
+ endif()
+
+ find_library(${prefix}_static_lib
+ NAMES "${static_lib_name}"
+ PATHS "${home}"
+ PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
+ NO_DEFAULT_PATH)
+ set(static_lib "${${prefix}_static_lib}")
+ set(${prefix}_STATIC_LIB
+ "${static_lib}"
+ PARENT_SCOPE)
+ if(static_lib)
+ add_library(${target_static} STATIC IMPORTED)
+ set_target_properties(${target_static} PROPERTIES IMPORTED_LOCATION "${static_lib}")
+ if(include_dir)
+ set_target_properties(${target_static} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+ "${include_dir}")
+ endif()
+ endif()
+endmacro()
+
+# Internal macro only for arrow_find_package.
+#
+# Find package by CMake package configuration.
+macro(arrow_find_package_cmake_package_configuration)
+ find_package(${cmake_package_name} CONFIG)
+ if(${cmake_package_name}_FOUND)
+ set(${prefix}_USE_CMAKE_PACKAGE_CONFIG
+ TRUE
+ PARENT_SCOPE)
+ if(TARGET ${target_shared})
+ foreach(suffix ${ARROW_CONFIG_SUFFIXES})
+ get_target_property(shared_lib ${target_shared} IMPORTED_LOCATION${suffix})
+ if(shared_lib)
+ # Remove shared library version:
+ # libarrow.so.100.0.0 -> libarrow.so
+ # Because ARROW_HOME and pkg-config approaches don't add
+ # shared library version.
+ string(REGEX REPLACE "(${CMAKE_SHARED_LIBRARY_SUFFIX})[.0-9]+$" "\\1"
+ shared_lib "${shared_lib}")
+ set(${prefix}_SHARED_LIB
+ "${shared_lib}"
+ PARENT_SCOPE)
+ break()
+ endif()
+ endforeach()
+ endif()
+ if(TARGET ${target_static})
+ foreach(suffix ${ARROW_CONFIG_SUFFIXES})
+ get_target_property(static_lib ${target_static} IMPORTED_LOCATION${suffix})
+ if(static_lib)
+ set(${prefix}_STATIC_LIB
+ "${static_lib}"
+ PARENT_SCOPE)
+ break()
+ endif()
+ endforeach()
+ endif()
+ endif()
+endmacro()
+
+# Internal macro only for arrow_find_package.
+#
+# Find package by pkg-config.
+macro(arrow_find_package_pkg_config)
+ pkg_check_modules(${prefix}_PC ${pkg_config_name})
+ if(${prefix}_PC_FOUND)
+ set(${prefix}_USE_PKG_CONFIG
+ TRUE
+ PARENT_SCOPE)
+
+ set(include_dir "${${prefix}_PC_INCLUDEDIR}")
+ set(lib_dir "${${prefix}_PC_LIBDIR}")
+ set(shared_lib_paths "${${prefix}_PC_LINK_LIBRARIES}")
+ # Use the first shared library path as the IMPORTED_LOCATION
+ # for ${target_shared}. This assumes that the first shared library
+ # path is the shared library path for this module.
+ list(GET shared_lib_paths 0 first_shared_lib_path)
+ # Use the rest shared library paths as the INTERFACE_LINK_LIBRARIES
+ # for ${target_shared}. This assumes that the rest shared library
+ # paths are dependency library paths for this module.
+ list(LENGTH shared_lib_paths n_shared_lib_paths)
+ if(n_shared_lib_paths LESS_EQUAL 1)
+ set(rest_shared_lib_paths)
+ else()
+ list(SUBLIST
+ shared_lib_paths
+ 1
+ -1
+ rest_shared_lib_paths)
+ endif()
+
+ set(${prefix}_VERSION
+ "${${prefix}_PC_VERSION}"
+ PARENT_SCOPE)
+ set(${prefix}_INCLUDE_DIR
+ "${include_dir}"
+ PARENT_SCOPE)
+ set(${prefix}_SHARED_LIB
+ "${first_shared_lib_path}"
+ PARENT_SCOPE)
+
+ add_library(${target_shared} SHARED IMPORTED)
+ set_target_properties(${target_shared}
+ PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}"
+ INTERFACE_LINK_LIBRARIES "${rest_shared_lib_paths}"
+ IMPORTED_LOCATION "${first_shared_lib_path}")
+ get_target_property(shared_lib ${target_shared} IMPORTED_LOCATION)
+
+ find_library(${prefix}_static_lib
+ NAMES "${static_lib_name}"
+ PATHS "${lib_dir}"
+ NO_DEFAULT_PATH)
+ set(static_lib "${${prefix}_static_lib}")
+ set(${prefix}_STATIC_LIB
+ "${static_lib}"
+ PARENT_SCOPE)
+ if(static_lib)
+ add_library(${target_static} STATIC IMPORTED)
+ set_target_properties(${target_static}
+ PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}"
+ IMPORTED_LOCATION "${static_lib}")
+ endif()
+ endif()
+endmacro()
+
+function(arrow_find_package
+ prefix
+ home
+ base_name
+ header_path
+ cmake_package_name
+ pkg_config_name)
+ arrow_build_shared_library_name(shared_lib_name ${base_name})
+ arrow_build_import_library_name(import_lib_name ${base_name})
+ arrow_build_static_library_name(static_lib_name ${base_name})
+
+ set(target_shared ${base_name}_shared)
+ set(target_static ${base_name}_static)
+
+ if(home)
+ arrow_find_package_home()
+ set(${prefix}_FIND_APPROACH
+ "HOME: ${home}"
+ PARENT_SCOPE)
+ else()
+ arrow_find_package_cmake_package_configuration()
+ if(${cmake_package_name}_FOUND)
+ set(${prefix}_FIND_APPROACH
+ "CMake package configuration: ${cmake_package_name}"
+ PARENT_SCOPE)
+ else()
+ arrow_find_package_pkg_config()
+ set(${prefix}_FIND_APPROACH
+ "pkg-config: ${pkg_config_name}"
+ PARENT_SCOPE)
+ endif()
+ endif()
+
+ if(NOT include_dir)
+ if(TARGET ${target_shared})
+ get_target_property(include_dir ${target_shared} INTERFACE_INCLUDE_DIRECTORIES)
+ elseif(TARGET ${target_static})
+ get_target_property(include_dir ${target_static} INTERFACE_INCLUDE_DIRECTORIES)
+ endif()
+ endif()
+ if(include_dir)
+ set(${prefix}_INCLUDE_DIR
+ "${include_dir}"
+ PARENT_SCOPE)
+ endif()
+
+ if(shared_lib)
+ get_filename_component(lib_dir "${shared_lib}" DIRECTORY)
+ elseif(static_lib)
+ get_filename_component(lib_dir "${static_lib}" DIRECTORY)
+ else()
+ set(lib_dir NOTFOUND)
+ endif()
+ set(${prefix}_LIB_DIR
+ "${lib_dir}"
+ PARENT_SCOPE)
+ # For backward compatibility
+ set(${prefix}_LIBS
+ "${lib_dir}"
+ PARENT_SCOPE)
+endfunction()
+
+if(NOT "$ENV{ARROW_HOME}" STREQUAL "")
+ file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME)
+endif()
+arrow_find_package(ARROW
+ "${ARROW_HOME}"
+ arrow
+ arrow/api.h
+ Arrow
+ arrow)
+
+if(ARROW_HOME)
+ if(ARROW_INCLUDE_DIR)
+ file(READ "${ARROW_INCLUDE_DIR}/arrow/util/config.h" ARROW_CONFIG_H_CONTENT)
+ arrow_extract_macro_value(ARROW_VERSION_MAJOR "ARROW_VERSION_MAJOR"
+ "${ARROW_CONFIG_H_CONTENT}")
+ arrow_extract_macro_value(ARROW_VERSION_MINOR "ARROW_VERSION_MINOR"
+ "${ARROW_CONFIG_H_CONTENT}")
+ arrow_extract_macro_value(ARROW_VERSION_PATCH "ARROW_VERSION_PATCH"
+ "${ARROW_CONFIG_H_CONTENT}")
+ if("${ARROW_VERSION_MAJOR}" STREQUAL ""
+ OR "${ARROW_VERSION_MINOR}" STREQUAL ""
+ OR "${ARROW_VERSION_PATCH}" STREQUAL "")
+ set(ARROW_VERSION "0.0.0")
+ else()
+ set(ARROW_VERSION
+ "${ARROW_VERSION_MAJOR}.${ARROW_VERSION_MINOR}.${ARROW_VERSION_PATCH}")
+ endif()
+
+ arrow_extract_macro_value(ARROW_SO_VERSION_QUOTED "ARROW_SO_VERSION"
+ "${ARROW_CONFIG_H_CONTENT}")
+ string(REGEX REPLACE "^\"(.+)\"$" "\\1" ARROW_SO_VERSION "${ARROW_SO_VERSION_QUOTED}")
+ arrow_extract_macro_value(ARROW_FULL_SO_VERSION_QUOTED "ARROW_FULL_SO_VERSION"
+ "${ARROW_CONFIG_H_CONTENT}")
+ string(REGEX REPLACE "^\"(.+)\"$" "\\1" ARROW_FULL_SO_VERSION
+ "${ARROW_FULL_SO_VERSION_QUOTED}")
+ endif()
+else()
+ if(ARROW_USE_CMAKE_PACKAGE_CONFIG)
+ find_package(Arrow CONFIG)
+ elseif(ARROW_USE_PKG_CONFIG)
+ pkg_get_variable(ARROW_SO_VERSION arrow so_version)
+ pkg_get_variable(ARROW_FULL_SO_VERSION arrow full_so_version)
+ endif()
+endif()
+
+set(ARROW_ABI_VERSION ${ARROW_SO_VERSION})
+
+mark_as_advanced(ARROW_ABI_VERSION
+ ARROW_CONFIG_SUFFIXES
+ ARROW_FULL_SO_VERSION
+ ARROW_IMPORT_LIB
+ ARROW_INCLUDE_DIR
+ ARROW_LIBS
+ ARROW_LIB_DIR
+ ARROW_SEARCH_LIB_PATH_SUFFIXES
+ ARROW_SHARED_IMP_LIB
+ ARROW_SHARED_LIB
+ ARROW_SO_VERSION
+ ARROW_STATIC_LIB
+ ARROW_VERSION
+ ARROW_VERSION_MAJOR
+ ARROW_VERSION_MINOR
+ ARROW_VERSION_PATCH)
+
+find_package_handle_standard_args(
+ Arrow
+ REQUIRED_VARS # The first required variable is shown
+ # in the found message. So this list is
+ # not sorted alphabetically.
+ ARROW_INCLUDE_DIR ARROW_LIB_DIR ARROW_FULL_SO_VERSION ARROW_SO_VERSION
+ VERSION_VAR ARROW_VERSION)
+set(ARROW_FOUND ${Arrow_FOUND})
+
+if(Arrow_FOUND AND NOT Arrow_FIND_QUIETLY)
+ message(STATUS "Arrow version: ${ARROW_VERSION} (${ARROW_FIND_APPROACH})")
+ message(STATUS "Arrow SO and ABI version: ${ARROW_SO_VERSION}")
+ message(STATUS "Arrow full SO version: ${ARROW_FULL_SO_VERSION}")
+ message(STATUS "Found the Arrow core shared library: ${ARROW_SHARED_LIB}")
+ message(STATUS "Found the Arrow core import library: ${ARROW_IMPORT_LIB}")
+ message(STATUS "Found the Arrow core static library: ${ARROW_STATIC_LIB}")
+endif()
--- /dev/null
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# - Find Parquet (parquet/api/reader.h, libparquet.a, libparquet.so)
+#
+# This module requires Arrow from which it uses
+# arrow_find_package()
+#
+# This module defines
+# PARQUET_FOUND, whether Parquet has been found
+# PARQUET_IMPORT_LIB, path to libparquet's import library (Windows only)
+# PARQUET_INCLUDE_DIR, directory containing headers
+# PARQUET_LIBS, deprecated. Use PARQUET_LIB_DIR instead
+# PARQUET_LIB_DIR, directory containing Parquet libraries
+# PARQUET_SHARED_IMP_LIB, deprecated. Use PARQUET_IMPORT_LIB instead
+# PARQUET_SHARED_LIB, path to libparquet's shared library
+# PARQUET_SO_VERSION, shared object version of found Parquet such as "100"
+# PARQUET_STATIC_LIB, path to libparquet.a
+
+if(DEFINED PARQUET_FOUND)
+ return()
+endif()
+
+set(find_package_arguments)
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION)
+ list(APPEND find_package_arguments "${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}")
+endif()
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+ list(APPEND find_package_arguments REQUIRED)
+endif()
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+ list(APPEND find_package_arguments QUIET)
+endif()
+find_package(Arrow ${find_package_arguments})
+
+if(NOT "$ENV{PARQUET_HOME}" STREQUAL "")
+ file(TO_CMAKE_PATH "$ENV{PARQUET_HOME}" PARQUET_HOME)
+endif()
+
+if((NOT PARQUET_HOME) AND ARROW_HOME)
+ set(PARQUET_HOME ${ARROW_HOME})
+endif()
+
+if(ARROW_FOUND)
+ arrow_find_package(PARQUET
+ "${PARQUET_HOME}"
+ parquet
+ parquet/api/reader.h
+ Parquet
+ parquet)
+ if(PARQUET_HOME)
+ if(PARQUET_INCLUDE_DIR)
+ file(READ "${PARQUET_INCLUDE_DIR}/parquet/parquet_version.h"
+ PARQUET_VERSION_H_CONTENT)
+ arrow_extract_macro_value(PARQUET_VERSION_MAJOR "PARQUET_VERSION_MAJOR"
+ "${PARQUET_VERSION_H_CONTENT}")
+ arrow_extract_macro_value(PARQUET_VERSION_MINOR "PARQUET_VERSION_MINOR"
+ "${PARQUET_VERSION_H_CONTENT}")
+ arrow_extract_macro_value(PARQUET_VERSION_PATCH "PARQUET_VERSION_PATCH"
+ "${PARQUET_VERSION_H_CONTENT}")
+ if("${PARQUET_VERSION_MAJOR}" STREQUAL ""
+ OR "${PARQUET_VERSION_MINOR}" STREQUAL ""
+ OR "${PARQUET_VERSION_PATCH}" STREQUAL "")
+ set(PARQUET_VERSION "0.0.0")
+ else()
+ set(PARQUET_VERSION
+ "${PARQUET_VERSION_MAJOR}.${PARQUET_VERSION_MINOR}.${PARQUET_VERSION_PATCH}")
+ endif()
+
+ arrow_extract_macro_value(PARQUET_SO_VERSION_QUOTED "PARQUET_SO_VERSION"
+ "${PARQUET_VERSION_H_CONTENT}")
+ string(REGEX REPLACE "^\"(.+)\"$" "\\1" PARQUET_SO_VERSION
+ "${PARQUET_SO_VERSION_QUOTED}")
+ arrow_extract_macro_value(PARQUET_FULL_SO_VERSION_QUOTED "PARQUET_FULL_SO_VERSION"
+ "${PARQUET_VERSION_H_CONTENT}")
+ string(REGEX REPLACE "^\"(.+)\"$" "\\1" PARQUET_FULL_SO_VERSION
+ "${PARQUET_FULL_SO_VERSION_QUOTED}")
+ endif()
+ else()
+ if(PARQUET_USE_CMAKE_PACKAGE_CONFIG)
+ find_package(Parquet CONFIG)
+ elseif(PARQUET_USE_PKG_CONFIG)
+ pkg_get_variable(PARQUET_SO_VERSION parquet so_version)
+ pkg_get_variable(PARQUET_FULL_SO_VERSION parquet full_so_version)
+ endif()
+ endif()
+ set(PARQUET_ABI_VERSION "${PARQUET_SO_VERSION}")
+endif()
+
+mark_as_advanced(PARQUET_ABI_VERSION
+ PARQUET_IMPORT_LIB
+ PARQUET_INCLUDE_DIR
+ PARQUET_LIBS
+ PARQUET_LIB_DIR
+ PARQUET_SHARED_IMP_LIB
+ PARQUET_SHARED_LIB
+ PARQUET_SO_VERSION
+ PARQUET_STATIC_LIB
+ PARQUET_VERSION)
+
+find_package_handle_standard_args(
+ Parquet
+ REQUIRED_VARS PARQUET_INCLUDE_DIR PARQUET_LIB_DIR PARQUET_SO_VERSION
+ VERSION_VAR PARQUET_VERSION)
+set(PARQUET_FOUND ${Parquet_FOUND})
+
+if(Parquet_FOUND AND NOT Parquet_FIND_QUIETLY)
+ message(STATUS "Parquet version: ${PARQUET_VERSION} (${PARQUET_FIND_APPROACH})")
+ message(STATUS "Found the Parquet shared library: ${PARQUET_SHARED_LIB}")
+ message(STATUS "Found the Parquet import library: ${PARQUET_IMPORT_LIB}")
+ message(STATUS "Found the Parquet static library: ${PARQUET_STATIC_LIB}")
+endif()
projects / ceph.git / commitdiff