[ceph.git] / ceph / cmake / modules / FindArrow.cmake

# 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

# cbodley copied this from the arrow submodule at v6.0.1
# cbodley added the import target Arrow::Arrow to match build_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()

if(Arrow_FOUND AND NOT TARGET Arrow::Arrow)
  add_library(Arrow::Arrow SHARED IMPORTED)
  set_target_properties(Arrow::Arrow PROPERTIES
    INTERFACE_INCLUDE_DIRECTORIES "${ARROW_INCLUDE_DIR}"
    IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
    IMPORTED_LOCATION "${ARROW_SHARED_LIB}")
endif()
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	# - Find Arrow (arrow/api.h, libarrow.a, libarrow.so)
	19	# This module defines
	20	# ARROW_FOUND, whether Arrow has been found
	21	# ARROW_FULL_SO_VERSION, full shared object version of found Arrow "100.0.0"
	22	# ARROW_IMPORT_LIB, path to libarrow's import library (Windows only)
	23	# ARROW_INCLUDE_DIR, directory containing headers
	24	# ARROW_LIBS, deprecated. Use ARROW_LIB_DIR instead
	25	# ARROW_LIB_DIR, directory containing Arrow libraries
	26	# ARROW_SHARED_IMP_LIB, deprecated. Use ARROW_IMPORT_LIB instead
	27	# ARROW_SHARED_LIB, path to libarrow's shared library
	28	# ARROW_SO_VERSION, shared object version of found Arrow such as "100"
	29	# ARROW_STATIC_LIB, path to libarrow.a
	30	# ARROW_VERSION, version of found Arrow
	31	# ARROW_VERSION_MAJOR, major version of found Arrow
	32	# ARROW_VERSION_MINOR, minor version of found Arrow
	33	# ARROW_VERSION_PATCH, patch version of found Arrow
	34
	35	# cbodley copied this from the arrow submodule at v6.0.1
	36	# cbodley added the import target Arrow::Arrow to match build_arrow()
	37
	38	if(DEFINED ARROW_FOUND)
	39	return()
	40	endif()
	41
	42	include(FindPkgConfig)
	43	include(FindPackageHandleStandardArgs)
	44
	45	if(WIN32 AND NOT MINGW)
	46	# This is used to handle builds using e.g. clang in an MSVC setting.
	47	set(MSVC_TOOLCHAIN TRUE)
	48	else()
	49	set(MSVC_TOOLCHAIN FALSE)
	50	endif()
	51
	52	set(ARROW_SEARCH_LIB_PATH_SUFFIXES)
	53	if(CMAKE_LIBRARY_ARCHITECTURE)
	54	list(APPEND ARROW_SEARCH_LIB_PATH_SUFFIXES "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
	55	endif()
	56	list(APPEND
	57	ARROW_SEARCH_LIB_PATH_SUFFIXES
	58	"lib64"
	59	"lib32"
	60	"lib"
	61	"bin")
	62	set(ARROW_CONFIG_SUFFIXES
	63	"_RELEASE"
	64	"_RELWITHDEBINFO"
65	"_MINSIZEREL"
66	"_DEBUG"
67	"")
68	if(CMAKE_BUILD_TYPE)
69	string(TOUPPER ${CMAKE_BUILD_TYPE} ARROW_CONFIG_SUFFIX_PREFERRED)
70	set(ARROW_CONFIG_SUFFIX_PREFERRED "_${ARROW_CONFIG_SUFFIX_PREFERRED}")
71	list(INSERT ARROW_CONFIG_SUFFIXES 0 "${ARROW_CONFIG_SUFFIX_PREFERRED}")
72	endif()
73
74	if(NOT DEFINED ARROW_MSVC_STATIC_LIB_SUFFIX)
75	if(MSVC_TOOLCHAIN)
76	set(ARROW_MSVC_STATIC_LIB_SUFFIX "_static")
77	else()
78	set(ARROW_MSVC_STATIC_LIB_SUFFIX "")
79	endif()
80	endif()
81
82	# Internal function.
83	#
84	# Set shared library name for ${base_name} to ${output_variable}.
85	#
86	# Example:
87	# arrow_build_shared_library_name(ARROW_SHARED_LIBRARY_NAME arrow)
88	# # -> ARROW_SHARED_LIBRARY_NAME=libarrow.so on Linux
89	# # -> ARROW_SHARED_LIBRARY_NAME=libarrow.dylib on macOS
90	# # -> ARROW_SHARED_LIBRARY_NAME=arrow.dll with MSVC on Windows
91	# # -> ARROW_SHARED_LIBRARY_NAME=libarrow.dll with MinGW on Windows
92	function(arrow_build_shared_library_name output_variable base_name)
93	set(${output_variable}
94	"${CMAKE_SHARED_LIBRARY_PREFIX}${base_name}${CMAKE_SHARED_LIBRARY_SUFFIX}"
95	PARENT_SCOPE)
96	endfunction()
97
98	# Internal function.
99	#
100	# Set import library name for ${base_name} to ${output_variable}.
101	# This is useful only for MSVC build. Import library is used only
102	# with MSVC build.
103	#
104	# Example:
105	# arrow_build_import_library_name(ARROW_IMPORT_LIBRARY_NAME arrow)
106	# # -> ARROW_IMPORT_LIBRARY_NAME=arrow on Linux (meaningless)
107	# # -> ARROW_IMPORT_LIBRARY_NAME=arrow on macOS (meaningless)
108	# # -> ARROW_IMPORT_LIBRARY_NAME=arrow.lib with MSVC on Windows
109	# # -> ARROW_IMPORT_LIBRARY_NAME=libarrow.dll.a with MinGW on Windows
110	function(arrow_build_import_library_name output_variable base_name)
111	set(${output_variable}
112	"${CMAKE_IMPORT_LIBRARY_PREFIX}${base_name}${CMAKE_IMPORT_LIBRARY_SUFFIX}"
113	PARENT_SCOPE)
114	endfunction()
115
116	# Internal function.
117	#
118	# Set static library name for ${base_name} to ${output_variable}.
119	#
120	# Example:
121	# arrow_build_static_library_name(ARROW_STATIC_LIBRARY_NAME arrow)
122	# # -> ARROW_STATIC_LIBRARY_NAME=libarrow.a on Linux
123	# # -> ARROW_STATIC_LIBRARY_NAME=libarrow.a on macOS
124	# # -> ARROW_STATIC_LIBRARY_NAME=arrow.lib with MSVC on Windows
125	# # -> ARROW_STATIC_LIBRARY_NAME=libarrow.dll.a with MinGW on Windows
126	function(arrow_build_static_library_name output_variable base_name)
127	set(${output_variable}
128	"${CMAKE_STATIC_LIBRARY_PREFIX}${base_name}${ARROW_MSVC_STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}"
129	PARENT_SCOPE)
130	endfunction()
131
132	# Internal function.
133	#
134	# Set macro value for ${macro_name} in ${header_content} to ${output_variable}.
135	#
136	# Example:
137	# arrow_extract_macro_value(version_major
138	# "ARROW_VERSION_MAJOR"
139	# "#define ARROW_VERSION_MAJOR 1.0.0")
140	# # -> version_major=1.0.0
141	function(arrow_extract_macro_value output_variable macro_name header_content)
142	string(REGEX MATCH "#define +${macro_name} +[^\r\n]+" macro_definition
143	"${header_content}")
144	string(REGEX REPLACE "^#define +${macro_name} +(.+)$" "\\1" macro_value
145	"${macro_definition}")
146	set(${output_variable}
147	"${macro_value}"
148	PARENT_SCOPE)
149	endfunction()
150
151	# Internal macro only for arrow_find_package.
152	#
153	# Find package in HOME.
154	macro(arrow_find_package_home)
155	find_path(${prefix}_include_dir "${header_path}"
156	PATHS "${home}"
157	PATH_SUFFIXES "include"
158	NO_DEFAULT_PATH)
159	set(include_dir "${${prefix}_include_dir}")
160	set(${prefix}_INCLUDE_DIR
161	"${include_dir}"
162	PARENT_SCOPE)
163
164	if(MSVC_TOOLCHAIN)
165	set(CMAKE_SHARED_LIBRARY_SUFFIXES_ORIGINAL ${CMAKE_FIND_LIBRARY_SUFFIXES})
166	# .dll isn't found by find_library with MSVC because .dll isn't included in
167	# CMAKE_FIND_LIBRARY_SUFFIXES.
168	list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_SHARED_LIBRARY_SUFFIX}")
169	endif()
170	find_library(${prefix}_shared_lib
171	NAMES "${shared_lib_name}"
172	PATHS "${home}"
173	PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
174	NO_DEFAULT_PATH)
175	if(MSVC_TOOLCHAIN)
176	set(CMAKE_SHARED_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_ORIGINAL})
177	endif()
178	set(shared_lib "${${prefix}_shared_lib}")
179	set(${prefix}_SHARED_LIB
180	"${shared_lib}"
181	PARENT_SCOPE)
182	if(shared_lib)
183	add_library(${target_shared} SHARED IMPORTED)
184	set_target_properties(${target_shared} PROPERTIES IMPORTED_LOCATION "${shared_lib}")
185	if(include_dir)
186	set_target_properties(${target_shared} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
187	"${include_dir}")
188	endif()
189	find_library(${prefix}_import_lib
190	NAMES "${import_lib_name}"
191	PATHS "${home}"
192	PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
193	NO_DEFAULT_PATH)
194	set(import_lib "${${prefix}_import_lib}")
195	set(${prefix}_IMPORT_LIB
196	"${import_lib}"
197	PARENT_SCOPE)
198	if(import_lib)
199	set_target_properties(${target_shared} PROPERTIES IMPORTED_IMPLIB "${import_lib}")
200	endif()
201	endif()
202
203	find_library(${prefix}_static_lib
204	NAMES "${static_lib_name}"
205	PATHS "${home}"
206	PATH_SUFFIXES ${ARROW_SEARCH_LIB_PATH_SUFFIXES}
207	NO_DEFAULT_PATH)
208	set(static_lib "${${prefix}_static_lib}")
209	set(${prefix}_STATIC_LIB
210	"${static_lib}"
211	PARENT_SCOPE)
212	if(static_lib)
213	add_library(${target_static} STATIC IMPORTED)
214	set_target_properties(${target_static} PROPERTIES IMPORTED_LOCATION "${static_lib}")
215	if(include_dir)
216	set_target_properties(${target_static} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
217	"${include_dir}")
218	endif()
219	endif()
220	endmacro()
221
222	# Internal macro only for arrow_find_package.
223	#
224	# Find package by CMake package configuration.
225	macro(arrow_find_package_cmake_package_configuration)
226	find_package(${cmake_package_name} CONFIG)
227	if(${cmake_package_name}_FOUND)
228	set(${prefix}_USE_CMAKE_PACKAGE_CONFIG
229	TRUE
230	PARENT_SCOPE)
231	if(TARGET ${target_shared})
232	foreach(suffix ${ARROW_CONFIG_SUFFIXES})
233	get_target_property(shared_lib ${target_shared} IMPORTED_LOCATION${suffix})
234	if(shared_lib)
235	# Remove shared library version:
236	# libarrow.so.100.0.0 -> libarrow.so
237	# Because ARROW_HOME and pkg-config approaches don't add
238	# shared library version.
239	string(REGEX REPLACE "(${CMAKE_SHARED_LIBRARY_SUFFIX})[.0-9]+$" "\\1"
240	shared_lib "${shared_lib}")
241	set(${prefix}_SHARED_LIB
242	"${shared_lib}"
243	PARENT_SCOPE)
244	break()
245	endif()
246	endforeach()
247	endif()
248	if(TARGET ${target_static})
249	foreach(suffix ${ARROW_CONFIG_SUFFIXES})
250	get_target_property(static_lib ${target_static} IMPORTED_LOCATION${suffix})
251	if(static_lib)
252	set(${prefix}_STATIC_LIB
253	"${static_lib}"
254	PARENT_SCOPE)
255	break()
256	endif()
257	endforeach()
258	endif()
259	endif()
260	endmacro()
261
262	# Internal macro only for arrow_find_package.
263	#
264	# Find package by pkg-config.
265	macro(arrow_find_package_pkg_config)
266	pkg_check_modules(${prefix}_PC ${pkg_config_name})
267	if(${prefix}_PC_FOUND)
268	set(${prefix}_USE_PKG_CONFIG
269	TRUE
270	PARENT_SCOPE)
271
272	set(include_dir "${${prefix}_PC_INCLUDEDIR}")
273	set(lib_dir "${${prefix}_PC_LIBDIR}")
274	set(shared_lib_paths "${${prefix}_PC_LINK_LIBRARIES}")
275	# Use the first shared library path as the IMPORTED_LOCATION
276	# for ${target_shared}. This assumes that the first shared library
277	# path is the shared library path for this module.
278	list(GET shared_lib_paths 0 first_shared_lib_path)
279	# Use the rest shared library paths as the INTERFACE_LINK_LIBRARIES
280	# for ${target_shared}. This assumes that the rest shared library
281	# paths are dependency library paths for this module.
282	list(LENGTH shared_lib_paths n_shared_lib_paths)
283	if(n_shared_lib_paths LESS_EQUAL 1)
284	set(rest_shared_lib_paths)
285	else()
286	list(SUBLIST
287	shared_lib_paths
288	1
289	-1
290	rest_shared_lib_paths)
291	endif()
292
293	set(${prefix}_VERSION
294	"${${prefix}_PC_VERSION}"
295	PARENT_SCOPE)
296	set(${prefix}_INCLUDE_DIR
297	"${include_dir}"
298	PARENT_SCOPE)
299	set(${prefix}_SHARED_LIB
300	"${first_shared_lib_path}"
301	PARENT_SCOPE)
302
303	add_library(${target_shared} SHARED IMPORTED)
304	set_target_properties(${target_shared}
305	PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}"
306	INTERFACE_LINK_LIBRARIES "${rest_shared_lib_paths}"
307	IMPORTED_LOCATION "${first_shared_lib_path}")
308	get_target_property(shared_lib ${target_shared} IMPORTED_LOCATION)
309
310	find_library(${prefix}_static_lib
311	NAMES "${static_lib_name}"
312	PATHS "${lib_dir}"
313	NO_DEFAULT_PATH)
314	set(static_lib "${${prefix}_static_lib}")
315	set(${prefix}_STATIC_LIB
316	"${static_lib}"
317	PARENT_SCOPE)
318	if(static_lib)
319	add_library(${target_static} STATIC IMPORTED)
320	set_target_properties(${target_static}
321	PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${include_dir}"
322	IMPORTED_LOCATION "${static_lib}")
323	endif()
324	endif()
325	endmacro()
326
327	function(arrow_find_package
328	prefix
329	home
330	base_name
331	header_path
332	cmake_package_name
333	pkg_config_name)
334	arrow_build_shared_library_name(shared_lib_name ${base_name})
335	arrow_build_import_library_name(import_lib_name ${base_name})
336	arrow_build_static_library_name(static_lib_name ${base_name})
337
338	set(target_shared ${base_name}_shared)
339	set(target_static ${base_name}_static)
340
341	if(home)
342	arrow_find_package_home()
343	set(${prefix}_FIND_APPROACH
344	"HOME: ${home}"
345	PARENT_SCOPE)
346	else()
347	arrow_find_package_cmake_package_configuration()
348	if(${cmake_package_name}_FOUND)
349	set(${prefix}_FIND_APPROACH
350	"CMake package configuration: ${cmake_package_name}"
351	PARENT_SCOPE)
352	else()
353	arrow_find_package_pkg_config()
354	set(${prefix}_FIND_APPROACH
355	"pkg-config: ${pkg_config_name}"
356	PARENT_SCOPE)
357	endif()
358	endif()
359
360	if(NOT include_dir)
361	if(TARGET ${target_shared})
362	get_target_property(include_dir ${target_shared} INTERFACE_INCLUDE_DIRECTORIES)
363	elseif(TARGET ${target_static})
364	get_target_property(include_dir ${target_static} INTERFACE_INCLUDE_DIRECTORIES)
365	endif()
366	endif()
367	if(include_dir)
368	set(${prefix}_INCLUDE_DIR
369	"${include_dir}"
370	PARENT_SCOPE)
371	endif()
372
373	if(shared_lib)
374	get_filename_component(lib_dir "${shared_lib}" DIRECTORY)
375	elseif(static_lib)
376	get_filename_component(lib_dir "${static_lib}" DIRECTORY)
377	else()
378	set(lib_dir NOTFOUND)
379	endif()
380	set(${prefix}_LIB_DIR
381	"${lib_dir}"
382	PARENT_SCOPE)
383	# For backward compatibility
384	set(${prefix}_LIBS
385	"${lib_dir}"
386	PARENT_SCOPE)
387	endfunction()
388
389	if(NOT "$ENV{ARROW_HOME}" STREQUAL "")
390	file(TO_CMAKE_PATH "$ENV{ARROW_HOME}" ARROW_HOME)
391	endif()
392	arrow_find_package(ARROW
393	"${ARROW_HOME}"
394	arrow
395	arrow/api.h
396	Arrow
397	arrow)
398
399	if(ARROW_HOME)
400	if(ARROW_INCLUDE_DIR)
401	file(READ "${ARROW_INCLUDE_DIR}/arrow/util/config.h" ARROW_CONFIG_H_CONTENT)
402	arrow_extract_macro_value(ARROW_VERSION_MAJOR "ARROW_VERSION_MAJOR"
403	"${ARROW_CONFIG_H_CONTENT}")
404	arrow_extract_macro_value(ARROW_VERSION_MINOR "ARROW_VERSION_MINOR"
405	"${ARROW_CONFIG_H_CONTENT}")
406	arrow_extract_macro_value(ARROW_VERSION_PATCH "ARROW_VERSION_PATCH"
407	"${ARROW_CONFIG_H_CONTENT}")
408	if("${ARROW_VERSION_MAJOR}" STREQUAL ""
409	OR "${ARROW_VERSION_MINOR}" STREQUAL ""
410	OR "${ARROW_VERSION_PATCH}" STREQUAL "")
411	set(ARROW_VERSION "0.0.0")
412	else()
413	set(ARROW_VERSION
414	"${ARROW_VERSION_MAJOR}.${ARROW_VERSION_MINOR}.${ARROW_VERSION_PATCH}")
415	endif()
416
417	arrow_extract_macro_value(ARROW_SO_VERSION_QUOTED "ARROW_SO_VERSION"
418	"${ARROW_CONFIG_H_CONTENT}")
419	string(REGEX REPLACE "^\"(.+)\"$" "\\1" ARROW_SO_VERSION "${ARROW_SO_VERSION_QUOTED}")
420	arrow_extract_macro_value(ARROW_FULL_SO_VERSION_QUOTED "ARROW_FULL_SO_VERSION"
421	"${ARROW_CONFIG_H_CONTENT}")
422	string(REGEX REPLACE "^\"(.+)\"$" "\\1" ARROW_FULL_SO_VERSION
423	"${ARROW_FULL_SO_VERSION_QUOTED}")
424	endif()
425	else()
426	if(ARROW_USE_CMAKE_PACKAGE_CONFIG)
427	find_package(Arrow CONFIG)
428	elseif(ARROW_USE_PKG_CONFIG)
429	pkg_get_variable(ARROW_SO_VERSION arrow so_version)
430	pkg_get_variable(ARROW_FULL_SO_VERSION arrow full_so_version)
431	endif()
432	endif()
433
434	set(ARROW_ABI_VERSION ${ARROW_SO_VERSION})
435
436	mark_as_advanced(ARROW_ABI_VERSION
437	ARROW_CONFIG_SUFFIXES
438	ARROW_FULL_SO_VERSION
439	ARROW_IMPORT_LIB
440	ARROW_INCLUDE_DIR
441	ARROW_LIBS
442	ARROW_LIB_DIR
443	ARROW_SEARCH_LIB_PATH_SUFFIXES
444	ARROW_SHARED_IMP_LIB
445	ARROW_SHARED_LIB
446	ARROW_SO_VERSION
447	ARROW_STATIC_LIB
448	ARROW_VERSION
449	ARROW_VERSION_MAJOR
450	ARROW_VERSION_MINOR
451	ARROW_VERSION_PATCH)
452
453	find_package_handle_standard_args(
454	Arrow
455	REQUIRED_VARS # The first required variable is shown
456	# in the found message. So this list is
457	# not sorted alphabetically.
458	ARROW_INCLUDE_DIR ARROW_LIB_DIR ARROW_FULL_SO_VERSION ARROW_SO_VERSION
459	VERSION_VAR ARROW_VERSION)
460	set(ARROW_FOUND ${Arrow_FOUND})
461
462	if(Arrow_FOUND AND NOT Arrow_FIND_QUIETLY)
463	message(STATUS "Arrow version: ${ARROW_VERSION} (${ARROW_FIND_APPROACH})")
464	message(STATUS "Arrow SO and ABI version: ${ARROW_SO_VERSION}")
465	message(STATUS "Arrow full SO version: ${ARROW_FULL_SO_VERSION}")
466	message(STATUS "Found the Arrow core shared library: ${ARROW_SHARED_LIB}")
467	message(STATUS "Found the Arrow core import library: ${ARROW_IMPORT_LIB}")
468	message(STATUS "Found the Arrow core static library: ${ARROW_STATIC_LIB}")
469	endif()
470
471	if(Arrow_FOUND AND NOT TARGET Arrow::Arrow)
472	add_library(Arrow::Arrow SHARED IMPORTED)
473	set_target_properties(Arrow::Arrow PROPERTIES
474	INTERFACE_INCLUDE_DIRECTORIES "${ARROW_INCLUDE_DIR}"
475	IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
476	IMPORTED_LOCATION "${ARROW_SHARED_LIB}")
477	endif()