Merge branch 'windows-cmakefiles' into 'main' (d312cf36) · Commits · tango-controls / TangoAccessControl

.gitlab-ci.yml

+64 −0

Original line number	Diff line number	Diff line
		variables:
		TANGO_VERSION: 9.4.1
		MYSQL_VERSION: "5.7"
		MYSQL_VERSION_PATCH: "36"
		MSVC_VERSION: v141
		GENERATOR_VERSION: Visual Studio 16 2019
		DEPS_PATH: C:/dependencies
		LIBTANGO: libtango_${TANGO_VERSION}_${MSVC_VERSION}_${ARCH}_static_release
		TANGO_PATH: ${DEPS_PATH}/${LIBTANGO}
		DEBIAN_FRONTEND: noninteractive
		CMAKE_BUILD_TYPE: Debug

		@@ -45,6 +53,62 @@ variables:
		paths:
		- usr-local.tar

		.build-template-win:
		rules:
		- if: '$ARCH == "x64"'
		variables:
		DOWNLOAD_URL: "https://gitlab.com/tango-controls/cppTango/-/package_files/67360212/download"
		MYSQL: "mysql-${MYSQL_VERSION}.${MYSQL_VERSION_PATCH}-winx64"
		MYSQL_PATH: "${DEPS_PATH}/${MYSQL}"
		- if: '$ARCH == "x86"'
		variables:
		DOWNLOAD_URL: "https://gitlab.com/tango-controls/cppTango/-/package_files/67361143/download"
		MYSQL: "mysql-${MYSQL_VERSION}.${MYSQL_VERSION_PATCH}-win32"
		MYSQL_PATH: "${DEPS_PATH}/${MYSQL}"
		before_script:
		- choco install cmake -y
		- $env:Path += ";C:\Program Files\CMake\bin"
		- $env:Path += ";C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\MSBuild\Current\Bin"
		- msbuild /version
		- if (Test-Path "${DEPS_PATH}") { Remove-Item "${DEPS_PATH}" -Recurse -Force; }
		- New-Item "${DEPS_PATH}" -ItemType Directory
		# See LIBTANGO constant at the top for the exact name
		- wget.exe "${DOWNLOAD_URL}" -P "${DEPS_PATH}"
		- 7z x "${DEPS_PATH}/download" -o"${DEPS_PATH}"
		- wget.exe "https://dev.mysql.com/get/Downloads/MySQL-${MYSQL_VERSION}/${MYSQL}.zip" -P "${DEPS_PATH}"
		- 7z x "${DEPS_PATH}/${MYSQL}.zip" -o"${DEPS_PATH}"
		script:
		- New-Item build -ItemType Directory
		- cd build
		# We set MySQL_VERSION to avoid a try_run invocation. The binary
		# requires the VC redistributable which we do not have on the CI
		- cmake -G"${GENERATOR_VERSION}" -A"${PLATFORM}" ../TangoAccessControl -DTango_ROOT="${TANGO_PATH}" -DMySQL_ROOT="${MYSQL_PATH}" -DTango_FORCE_STATIC=ON -DMySQL_VERSION="${MYSQL_VERSION}.${MYSQL_VERSION_PATH}"
		- cmake --build . --config Release
		- cmake --install .
		after_script:
		- New-Item artifacts -ItemType Directory
		- if (Test-Path "C:\Program Files\TangoAccessControl\bin") { Move-Item -Path "C:\Program Files\TangoAccessControl\bin\TangoAccessControl.exe" -Destination "artifacts\TangoAccessControl-x64.exe"; }
		- if (Test-Path "C:\Program Files (x86)\TangoAccessControl\bin") { Move-Item -Path "C:\Program Files (x86)\TangoAccessControl\bin\TangoAccessControl.exe" -Destination "artifacts\TangoAccessControl-x86.exe"; }
		artifacts:
		paths:
		- artifacts
		expire_in: 1 day
		tags:
		- shared-windows

		build-win-64bit:
		extends: .build-template-win
		variables:
		ARCH: x64
		PLATFORM: x64

		build-win-32bit:
		extends: .build-template-win
		variables:
		ARCH: x86
		PLATFORM: Win32


		build-cppTango-main:
		variables:
		BRANCH: main

README.md

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		# TangoAccessControl

		Access control device server for Tango.

		## Building

		To build, from this directory:

		```
		cmake -Bbuild -STangoAccessControl
		cmake --build build
		```

		By default (on Linux), CMake will use pkg-config to find your installation of
		tango. This can be disabled by passing -DTango_USE_PKG_CONFIG=OFF to CMake. If
		pkg-config cannot find tango, or pkg-config is disabled, CMake will try to
		search for tango and its dependencies on your system. You can provide hints to
		cmake using either the -DCMAKE_PREFIX_PATH variable or the -DTango_ROOT variable
		(cmake 3.12 or later).

		cmake will also search for the MySQL dependency, hints can be provided with
		-DCMAKE_PREFIX_PATH and -DMySQL_ROOT (cmake 3.12 or later).

		### Notable CMake Variables

		\| Name \| Default \| Description \| Notes \|
		\| --- \| --- \| --- \| --- \|
		\| -DTango_USE_PKG_CONFIG \| OFF (Windows) ON (Linux) \| Use pkg-config to find Tango \| \|
		\| -DTango_FORCE_STATIC \| OFF \| Force TangoAccessControl to link against the static libtango library \| Fails if no static library found \|
		\| -DCMAKE_PREFIX_PATH \| "" \| ;-separated list of prefix paths to search for dependencies in \| \|
		\| -DTango_ROOT \| "" \| Prefix path to find Tango dependency \| CMake 3.12 or later \|
		\| -DMySQL_ROOT \| "" \| Prefix path to find MySQL dependency \| CMake 3.12 or later \|
		\| -DZeroMQ_ROOT \| "" \| Prefix path to find ZeroMQ dependency \| CMake 3.12 or later \|
		\| -Dcppzmq_ROOT \| "" \| Prefix path to find cppzmq dependency \| CMake 3.12 or later \|
		\| -DomniORB4_ROOT \| "" \| Prefix path to find omniORB4 dependency \| CMake 3.12 or later \|

TangoAccessControl/CMakeLists.txt

+45 −22

Original line number	Diff line number	Diff line
		cmake_minimum_required(VERSION 3.7 FATAL_ERROR)
		project(TangoAccessControl)
		cmake_minimum_required(VERSION 3.7...3.22 FATAL_ERROR)
		project(TangoAccessControl VERSION 2.19 LANGUAGES CXX)

		if(NOT CMAKE_BUILD_TYPE)
		message("No build type specified - default is DEBUG")
		set(CMAKE_BUILD_TYPE DEBUG)
		# Ensure we have access to MSVC_RUNTIME_LIBRARY property for Windows builds
		if (WIN32 AND NOT CMAKE_VERSION VERSION_GREATER_EQUAL 3.15)
		message(FATAL_ERROR "cmake ${CMAKE_VERSION} is not supported for Windows builds")
		endif()

		include(FindPkgConfig)
		include(configure/FindMySQL.cmake)
		if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.11)
		get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
		elseif(CMAKE_CONFIGURATION_TYPES)
		set(IS_MULTI_CONFIG YES)
		else()
		set(IS_MULTI_CONFIG NO)
		endif()

		if(NOT MYSQL_FOUND)
		message(SEND_ERROR " Can not find MySQL client library.")
		if(NOT CMAKE_BUILD_TYPE AND NOT IS_MULTI_CONFIG)
		message(STATUS "No build type specified - default is DEBUG")
		set(CMAKE_BUILD_TYPE DEBUG)
		endif()

		pkg_search_module(TANGO_PKG REQUIRED tango)
		list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
		find_package(MySQL REQUIRED)
		find_package(Tango REQUIRED)

		set(SOURCES ClassFactory.cpp
		DbUtils.cpp
		@@ -26,21 +34,36 @@ set(ADDITIONAL_SOURCES ../AbstractClasses/AccessControl.cpp
		../AbstractClasses/AccessControlClass.cpp
		../AbstractClasses/AccessControlStateMachine.cpp)

		include_directories(../AbstractClasses ${TANGO_PKG_INCLUDE_DIRS} ${MYSQL_INCLUDE_DIRS})
		link_directories(${TANGO_PKG_LIBRARY_DIRS})
		set(HEADERS Logging.h
		TangoAccessControl.h
		TangoAccessControlClass.h)

		set(ADDITIONAL_HEADERS ../AbstractClasses/AccessControl.h
		../AbstractClasses/AccessControlClass.h)

		add_executable(TangoAccessControl ${SOURCES} ${ADDITIONAL_SOURCES})
		target_link_libraries(TangoAccessControl ${TANGO_PKG_LIBRARIES} ${MYSQL_LIBRARIES})
		target_compile_options(TangoAccessControl PUBLIC ${TANGO_PKG_CFLAGS_OTHER} -Wall -Wextra -D_FORTIFY_SOURCE=2 -O1)
		add_executable(TangoAccessControl ${SOURCES} ${ADDITIONAL_SOURCES} ${HEADERS} ${ADDITIONAL_HEADERS})
		target_link_libraries(TangoAccessControl PUBLIC Tango::Tango MySQL::MySQL)
		target_include_directories(TangoAccessControl PUBLIC ../AbstractClasses)

		if (WIN32 AND (Tango_IS_STATIC OR Tango_FORCE_STATIC))
		set_target_properties(${PROJECT_NAME} PROPERTIES
		MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
		)
		endif()


		if (MSVC)
		target_compile_options(TangoAccessControl PUBLIC /W3)
		else()
		target_compile_options(TangoAccessControl PUBLIC -Wall -Wextra -D_FORTIFY_SOURCE=2 -O1)

		message("Compiler: ${CMAKE_CXX_COMPILER_ID}")
		if(NOT (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
		target_compile_options(TangoAccessControl PUBLIC -fpie)
		set_target_properties(TangoAccessControl PROPERTIES LINK_FLAGS "-Wl,-z,now,-pie")
		set_target_properties(TangoAccessControl PROPERTIES LINK_FLAGS "-Wl,-z,now -pie")
		else()
		set_target_properties(TangoAccessControl PROPERTIES LINK_FLAGS "-bind_at_load")
		endif()
		endif()

		install(TARGETS TangoAccessControl
		RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}"
		CONFIGURATIONS ${CMAKE_BUILD_TYPE})
		RUNTIME DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}")

TangoAccessControl/cmake/FindMySQL.cmake

0 → 100644

+217 −0

Original line number	Diff line number	Diff line
		#[=======================================================================[.rst:
		FindMySQL
		---------

		Find MySQL library

		Imported Targets
		^^^^^^^^^^^^^^^^

		This module provides the following imported targets, if found:

		``MySQL::MySQL``
		The MySQL client library
		``MySQL::exe``
		The MySQL client executable

		Result Variables
		^^^^^^^^^^^^^^^^

		This will define the following variables:

		``MySQL_FOUND``
		True if the system has the MySQL library.
		``MySQL_exe_FOUND``
		True if the system has the MySQL library.
		``MySQL_VERSION``
		The version of the MySQL library which was found, if known

		Cache Variables
		^^^^^^^^^^^^^^^

		The following cache variables may also be set:

		``MySQL_INCLUDE_DIR``
		The directory containing ``mysql.h``.
		``MySQL_LIBRARY_RELEASE``
		The path to the release MySQL library.
		``MySQL_LIBRARY_DEBUG``
		The path to the debug MySQL library.
		``MySQL_LIBRARY``
		The path to the release MySQL library or the debug library
		if the release library is not found.
		``MySQL_EXECUTABLE``
		The path to the mysql client program

		#]=======================================================================]

		if (NOT DEFINED PKG_CONFIG_FOUND)
		find_package(PkgConfig QUIET)
		endif()

		# Collect hints from pkg-config
		if (PKG_CONFIG_FOUND)
		pkg_search_module(_MySQL_PKG mysql mariadb QUIET)
		endif()

		if (WIN32)
		set(_mysql_inc_paths
		"$ENV{ProgramFiles}/MySQL/*/include"
		"$ENV{ProgramFiles$x86$}/MySQL/*/include"
		"$ENV{ProgramFiles}/MariaDB/*/include"
		"$ENV{ProgramFiles$x86$}/MariaDB/*/include"
		"$ENV{ProgramFiles}/MariaDB/include"
		"$ENV{ProgramFiles$x86$}/MariaDB/include"
		)
		endif()

		find_path(MySQL_INCLUDE_DIR
		NAMES "mysql.h"
		PATHS
		${_mysql_inc_paths}
		"${_MySQL_PKG_INCLUDE_DIRS}"
		PATH_SUFFIXES mysql mariadb
		)
		unset(_mysql_inc_paths)

		if (WIN32)
		set(_mysql_release_names libmysql libmariadb)
		set(_mysql_debug_names libmysqld libmariadbd)
		set(_mysql_lib_paths
		"$ENV{ProgramFiles}/MySQL/*/lib"
		"$ENV{ProgramFiles$x86$}/MySQL/*/lib"
		"$ENV{ProgramFiles}/MariaDB/*/lib"
		"$ENV{ProgramFiles$x86$}/MariaDB/*/lib"
		"$ENV{ProgramFiles}/MariaDB/lib"
		"$ENV{ProgramFiles$x86$}/MariaDB/lib"
		)
		else()
		set(_mysql_release_names mysqlclient mysqlclient_r mariadb)
		set(_mysql_debug_names mysqlclient mysqlclient_r mariadb)
		endif()

		find_library(MySQL_LIBRARY_RELEASE
		NAMES ${_mysql_release_names}
		NAMES_PER_DIR
		PATHS
		""
		${_mysql_lib_paths}
		${_MySQL_PKG_LIBRARY_DIRS}
		)

		find_library(MySQL_LIBRARY_DEBUG
		NAMES ${_mysql_debug_names}
		NAMES_PER_DIR
		PATHS
		""
		${_mysql_lib_paths}
		${_MySQL_PKG_LIBRARY_DIRS}
		)

		unset(_mysql_lib_paths)
		unset(_mysql_release_names)
		unset(_mysql_debug_names)

		include(SelectLibraryConfigurations)
		select_library_configurations(MySQL)

		if (WIN32)
		set(_mysql_bin_paths
		"$ENV{ProgramFiles}/MySQL/*/bin"
		"$ENV{ProgramFiles$x86$}/MySQL/*/bin"
		"$ENV{ProgramFiles}/MariaDB/*/bin"
		"$ENV{ProgramFiles$x86$}/MariaDB/*/bin"
		"$ENV{ProgramFiles}/MariaDB/bin"
		"$ENV{ProgramFiles$x86$}/MariaDB/bin"
		)
		endif()

		find_program(MySQL_EXECUTABLE
		NAMES mariadb mysql
		NAMES_PER_DIR
		PATHS
		${_mysql_bin_paths}
		)

		if (MySQL_EXECUTABLE)
		set(MySQL_exe_FOUND TRUE)
		endif()

		if (NOT MySQL_INCLUDE_DIR)
		set(MySQL_VERSION MySQL_VERSION-NOTFOUND)
		endif()

		if(NOT DEFINED MySQL_VERSION)
		try_run(
		DB_CLIENT_RUN
		DB_CLIENT_COMPILE
		${CMAKE_CURRENT_BINARY_DIR}
		${CMAKE_CURRENT_LIST_DIR}/test_db_client.cpp
		COMPILE_DEFINITIONS "-I \"${MySQL_INCLUDE_DIR}\""
		LINK_LIBRARIES ${MySQL_LIBRARY}
		COMPILE_OUTPUT_VARIABLE DB_CLIENT_COMPILE_OUTPUT
		RUN_OUTPUT_VARIABLE DB_CLIENT_VERSION)

		if (NOT DB_CLIENT_COMPILE)
		message(FATAL_ERROR "Failed to compile simple database client program:\n${DB_CLIENT_COMPILE_OUTPUT}")
		endif()

		if (NOT DB_CLIENT_RUN EQUAL 0)
		message(FATAL_ERROR "Failed to run simple database client program:\n${DB_CLIENT_VERSION}")
		endif()

		string(STRIP "${DB_CLIENT_VERSION}" DB_CLIENT_VERSION)
		set(MySQL_VERSION ${DB_CLIENT_VERSION} CACHE INTERNAL "database client library version")
		endif()

		include(FindPackageHandleStandardArgs)
		find_package_handle_standard_args(MySQL
		FOUND_VAR MySQL_FOUND
		REQUIRED_VARS
		MySQL_LIBRARY
		MySQL_INCLUDE_DIR
		VERSION_VAR MySQL_VERSION
		HANDLE_COMPONENTS)

		if (MySQL_FOUND)
		mark_as_advanced(MySQL_INCLUDE_DIR)
		mark_as_advanced(MySQL_LIBRARY_RELEASE)
		mark_as_advanced(MySQL_LIBRARY_DEBUG)
		mark_as_advanced(MySQL_LIBRARY)
		endif()

		if (MySQL_FOUND)
		if (NOT TARGET MySQL::MySQL)
		add_library(MySQL::MySQL UNKNOWN IMPORTED)
		endif()
		if (MySQL_LIBRARY_RELEASE)
		set_property(TARGET MySQL::MySQL APPEND PROPERTY
		IMPORTED_CONFIGURATIONS RELEASE
		)
		set_target_properties(MySQL::MySQL PROPERTIES
		IMPORTED_LOCATION_RELEASE "${MySQL_LIBRARY_RELEASE}"
		)
		endif()
		if (MySQL_LIBRARY_DEBUG)
		set_property(TARGET MySQL::MySQL APPEND PROPERTY
		IMPORTED_CONFIGURATIONS DEBUG
		)
		set_target_properties(MySQL::MySQL PROPERTIES
		IMPORTED_LOCATION_DEBUG "${MySQL_LIBRARY_DEBUG}"
		)
		endif()
		set_target_properties(MySQL::MySQL PROPERTIES
		INTERFACE_INCLUDE_DIRECTORIES "${MySQL_INCLUDE_DIR}"
		INTERFACE_DEFINITIONS "${_MySQL_PKG_CFLAGS_OTHER}"
		)
		endif()

		if (MySQL_exe_FOUND)
		mark_as_advanced(MySQL_EXECUTABLE)
		endif()

		if (MySQL_exe_FOUND AND NOT TARGET MySQL::exe)
		add_executable(MySQL::exe IMPORTED)
		set_property(TARGET MySQL::exe PROPERTY IMPORTED_LOCATION "${MySQL_EXECUTABLE}")
		endif()

TangoAccessControl/cmake/FindTango.cmake

0 → 100644

+299 −0

Original line number	Diff line number	Diff line
		#[=======================================================================[.rst:
		FindTango
		---------

		Find Tango library

		Imported Targets
		^^^^^^^^^^^^^^^^

		This module provides the following imported targets, if found:

		``Tango::Tango``
		The Tango library

		Result Variables
		^^^^^^^^^^^^^^^^

		This will define the following variables:

		``Tango_FOUND``
		True if the system has the Tango library.

		Cache Variables
		^^^^^^^^^^^^^^^

		The following cache vairables can be used to control the behaviour of this find
		module.

		``Tango_USE_PKG_CONFIG``
		Set to OFF to disable using pkg-config to find Tango.
		``Tango_FORCE_STATIC``
		Force Tango to use static libraries

		The following cache variables may also be set:

		``Tango_INCLUDE_DIR``
		The directory containing ``tango/tango.h``.
		``Tango_LIBRARY``
		The path to the Tango library.

		#]=======================================================================]

		function(_tango_find_version)
		if (NOT Tango_INCLUDE_DIR)
		set(Tango_VERSION Tango_VERSION-NOTFOUND PARENT_SCOPE)
		return()
		endif()

		# File containing version information. We should find it under tango for 9.3.x
		# releases and under tango/common for post 9.4.0 releases.
		find_file(tango_const_include_file
		NAMES tango_const.h
		PATHS
		${Tango_INCLUDE_DIR}/tango
		${Tango_INCLUDE_DIR}/tango/common
		NO_DEFAULT_PATH
		)

		if (NOT tango_const_include_file)
		message(WARNING "Could not fine tango_const.h under ${Tango_INCLUDE_DIR}")
		set(Tango_VERSION Tango_VERSION-NOTFOUND PARENT_SCOPE)
		return()
		endif()

		file(STRINGS ${tango_const_include_file} version_info
		REGEX "^#define[ \t]+TANGO_VERSION_(MAJOR\|MINOR\|PATCH).*")
		unset(tango_const_include_file CACHE)

		list(LENGTH version_info version_info_length)

		if (NOT version_info_length EQUAL 3)
		message(WARNING "Could not find version information in ${tango_const_include_file}")
		set(Tango_VERSION Tango_VERSION-NOTFOUND PARENT_SCOPE)
		return()
		endif()

		list(GET version_info 0 version_major_info)
		list(GET version_info 1 version_minor_info)
		list(GET version_info 2 version_patch_info)

		string(REGEX REPLACE "^#define[ \t]+TANGO_VERSION_MAJOR[ \t]+([0-9]+)$" "\\1" version_major ${version_major_info})
		string(REGEX REPLACE "^#define[ \t]+TANGO_VERSION_MINOR[ \t]+([0-9]+)$" "\\1" version_minor ${version_minor_info})
		string(REGEX REPLACE "^#define[ \t]+TANGO_VERSION_PATCH[ \t]+([0-9]+)$" "\\1" version_patch ${version_patch_info})

		set(Tango_VERSION ${version_major}.${version_minor}.${version_patch} CACHE INTERNAL "Tango Version")
		set(Tango_VERSION_MAJOR ${version_major} PARENT_SCOPE)
		set(Tango_VERSION_MINOR ${version_minor} PARENT_SCOPE)
		set(Tango_VERSION_PATCH ${version_patch} PARENT_SCOPE)
		endfunction()

		if (WIN32)
		set(_tango_default_use_pkg_config OFF)
		else()
		set(_tango_default_use_pkg_config ON)
		endif()
		option(Tango_USE_PKG_CONFIG "Use pkg-config to find Tango" ${_tango_default_use_pkg_config})
		unset(_tango_default_use_pkg_config)

		option(Tango_FORCE_STATIC "Statically link Tango" OFF)
		if(Tango_FORCE_STATIC AND Tango_USE_PKG_CONFIG)
		message(STATUS "Cannot set -DTango_FORCE_STATIC and -DTango_USE_PKG_CONFIG at the same time. Forcing -DTango_USE_PKG_CONFIG to OFF")
		set(Tango_USE_PKG_CONFIG OFF)
		endif()

		if (NOT Tango_USE_PKG_CONFIG OR Tango_FIND_QUIETLY)
		set(_tango_pkg_config_quiet QUIET)
		endif()
		find_package(PkgConfig ${_tango_pkg_config_quiet})
		unset(_tango_pkg_config_quiet)
		if (PKG_CONFIG_FOUND)
		if (Tango_FIND_REQUIRED AND NOT Tango_FIND_QUIETLY AND Tango_USE_PKG_CONFIG)
		pkg_search_module(_Tango_PKG tango IMPORTED_TARGET)
		else()
		pkg_search_module(_Tango_PKG tango QUIET IMPORTED_TARGET)
		endif()
		endif()

		if (_Tango_PKG_FOUND AND Tango_USE_PKG_CONFIG)
		if (NOT TARGET Tango::Tango)
		add_library(Tango::Tango ALIAS PkgConfig::_Tango_PKG)
		endif()
		if (NOT Tango_FIND_QUIETLY)
		message(STATUS "Tango found via pkg-config")
		endif()
		set(Tango_FOUND TRUE)
		return()
		endif()

		if (NOT _Tango_PKG_FOUND AND Tango_USE_PKG_CONFIG AND NOT Tango_FIND_QUIETLY)
		message(STATUS "Tango not found via pkg-config, falling back to cmake find")
		endif()

		# This will not find the header file for the (Windows?) 9.3.5 release, however,
		# I don't think this device server will work with the 9.3.5 release.
		find_path(Tango_INCLUDE_DIR
		NAMES tango/tango.h
		PATHS "" ${_Tango_PKG_INCLUDE_DIRS}
		)

		_tango_find_version()

		if (WIN32)
		set(_tango_release_names tango)
		set(_tango_debug_names tangod)
		set(_tango_static_release_names libtango)
		set(_tango_static_debug_names libtangod)
		else()
		set(_tango_release_names tango)
		set(_tango_debug_names tango)
		set(_tango_static_release_names tango)
		set(_tango_static_debug_names tango)
		endif()

		find_library(Tango_LIBRARY_RELEASE
		NAMES ${_tango_release_names}
		PATHS "" ${_Tango_PKG_LIBRARY_DIRS}
		)

		find_library(Tango_LIBRARY_RELEASE
		NAMES ${_tango_static_release_names}
		PATHS "" ${_Tango_PKG_LIBRARY_DIRS}
		)

		find_library(Tango_LIBRARY_DEBUG
		NAMES ${_tango_debug_names}
		PATHS "" ${_Tango_PKG_LIBRARY_DIRS}
		)

		find_library(Tango_LIBRARY_DEBUG
		NAMES ${_tango_static_debug_names}
		PATHS "" ${_Tango_PKG_LIBRARY_DIRS}
		)

		find_library(Tango_static_LIBRARY_RELEASE
		NAMES ${_tango_static_release_names}
		PATHS "" ${_Tango_PKG_LIBRARY_DIRS}
		)

		find_library(Tango_static_LIBRARY_DEBUG
		NAMES ${_tango_static_debug_names}
		PATHS "" ${_Tango_PKG_LIBRARY_DIRS}
		)

		unset(_tango_release_names)
		unset(_tango_debug_names)
		unset(_tango_static_release_names)
		unset(_tango_static_debug_names)

		include(SelectLibraryConfigurations)
		select_library_configurations(Tango)
		select_library_configurations(Tango_static)

		if(Tango_LIBRARY STREQUAL Tango_static_LIBRARY)
		set(Tango_IS_STATIC TRUE)
		endif()

		if (Tango_static_LIBRARY)
		set(Tango_static_FOUND TRUE)
		endif()

		if(Tango_FIND_QUIETLY)
		set(_tango_quiet QUIET)
		endif()

		find_package(cppzmq ${_tango_quiet})
		find_package(omniORB4 ${_tango_quiet}
		COMPONENTS COS4 Dynamic4)
		unset(_tango_quiet)

		include(FindPackageHandleStandardArgs)
		find_package_handle_standard_args(Tango
		FOUND_VAR Tango_FOUND
		REQUIRED_VARS
		Tango_LIBRARY
		Tango_INCLUDE_DIR
		cppzmq_FOUND
		omniORB4_FOUND
		omniORB4_COS4_FOUND
		omniORB4_Dynamic4_FOUND
		VERSION_VAR Tango_VERSION
		)

		if (Tango_FOUND)
		mark_as_advanced(Tango_INCLUDE_DIR)
		mark_as_advanced(Tango_LIBRARY)
		mark_as_advanced(Tango_LIBRARY_RELEASE)
		mark_as_advanced(Tango_LIBRARY_DEBUG)
		endif()

		if (Tango_static_FOUND)
		mark_as_advanced(Tango_static_LIBRARY)
		mark_as_advanced(Tango_static_LIBRARY_RELEASE)
		mark_as_advanced(Tango_static_LIBRARY_DEBUG)
		endif()

		function(_tango_add_target prefix targetsuffix is_static)
		if (NOT TARGET Tango::Tango)
		add_library(Tango::Tango UNKNOWN IMPORTED)
		endif()

		if (${prefix}_LIBRARY_RELEASE)
		set_property(TARGET Tango::Tango APPEND PROPERTY
		IMPORTED_CONFIGURATIONS RELEASE
		)
		set_target_properties(Tango::Tango PROPERTIES
		IMPORTED_LOCATION_RELEASE "${${prefix}_LIBRARY_RELEASE}"
		)
		endif()
		if (${prefix}_LIBRARY_DEBUG)
		set_property(TARGET Tango::Tango APPEND PROPERTY
		IMPORTED_CONFIGURATIONS DEBUG
		)
		set_target_properties(Tango::Tango PROPERTIES
		IMPORTED_LOCATION_DEBUG "${${prefix}_LIBRARY_DEBUG}"
		)
		endif()

		set(_tango_inc_dirs "${Tango_INCLUDE_DIR}")
		# For the 9.3.6 release the header files include each other without the "tango/" prefix, however,
		# our device server is including "tango/tango.h" so we need both directories in our include dirs.
		if (Tango_VERSION VERSION_LESS 9.4.0)
		list(APPEND _tango_inc_dirs "${Tango_INCLUDE_DIR}/tango")
		endif()

		set(_tango_dependents
		cppzmq::cppzmq${targetsuffix}
		omniORB4::omniORB4${targetsuffix}
		omniORB4::COS4${targetsuffix}
		omniORB4::Dynamic4${targetsuffix})

		if (WIN32)
		if(NOT is_static)
		set(_tango_definitions /DTANGO_HAS_DLL /DLOG4TANGO_HAS_DLL)
		else()
		set(_tango_definitions /D_WINSTATIC)
		list(APPEND _tango_dependents comctl32.lib)
		endif()
		endif()

		set_target_properties(Tango::Tango PROPERTIES
		INTERFACE_INCLUDE_DIRECTORIES "${_tango_inc_dirs}"
		INTERFACE_COMPILE_OPTIONS "${_tango_definitions}"
		INTERFACE_LINK_LIBRARIES "${_tango_dependents}"
		)

		unset(_tango_inc_dirs)
		unset(_tango_dependents)
		unset(_tango_defintions)
		endfunction()

		if (Tango_FORCE_STATIC AND NOT Tango_static_FOUND)
		message(FATAL_ERROR "Could not find static Tango when forcing static")
		endif()

		if (Tango_FORCE_STATIC)
		_tango_add_target(Tango_static "-static" TRUE)
		elseif (Tango_FOUND)
		_tango_add_target(Tango "" "${Tango_IS_STATIC}")
		endif()