generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2024-12-12 10:13:51 +01:00
Code Issues Projects Releases Wiki Activity

CMake: Create PocoConfig.cmake to make importable from other CMake projects

Browse Source 
The generated PocoConfig.cmake can be used by other CMake projects using find_package.
This commit is contained in:
Pascal Bach 2014-10-09 13:42:51 +02:00
parent c5ffa2629d
commit b69fafb84c
39 changed files with 677 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ApacheConnector/CMakeLists.txt
View File

@ -8,14 +8,18 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
include_directories( "include" )
add_library( ${LIBNAME} SHARED ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" SHARED ${SRCS} )
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL ApacheHandlers_EXPORTS)
target_link_libraries( ${LIBNAME} )
target_link_libraries( "${LIBNAME}" )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
if (ENABLE_TESTS)
add_subdirectory(samples)

98
CMakeLists.txt
View File

@ -8,7 +8,7 @@
project(Poco)
cmake_minimum_required(VERSION 2.8.0)
cmake_minimum_required(VERSION 3.0.0)
file(STRINGS "${CMAKE_SOURCE_DIR}/libversion" SHARED_LIBRARY_VERSION)
@ -75,12 +75,18 @@ option(ENABLE_PDF "Enable PDF" ON)
option(ENABLE_UTIL "Enable Util" ON)
option(ENABLE_NET "Enable Net" ON)
option(ENABLE_NETSSL "Enable NetSSL" ON)
option(ENABLE_NETSSL_WIN "Enable NetSSL Windows" ON)
option(ENABLE_CRYPTO "Enable Crypto" ON)
option(ENABLE_DATA "Enable Data" ON)
option(ENABLE_DATA_SQLITE "Enable Data SQlite" ON)
option(ENABLE_DATA_MYSQL "Enable Data MySQL" ON)
option(ENABLE_DATA_ODBC "Enable Data ODBC" ON)
option(ENABLE_SEVENZIP "Enable SevenZip" ON)
option(ENABLE_ZIP "Enable Zip" ON)
option(ENABLE_APACHECONNECTOR "Enable ApacheConnector" ON)
option(FORCE_OPENSSL "Force usage of OpenSSL even under windows" OFF)
option(ENABLE_TESTS
"Set to OFF|ON (default is OFF) to control build of POCO tests & samples" OFF)
@ -115,32 +121,21 @@ else ()
message(STATUS "Build with using internal copy of sqlite, libz, pcre, expat, ...")
endif ()
# Set local include path
include_directories( CppUnit/include CppUnit/WinTestRunner/include Foundation/include XML/include Net/include NetSSL_OpenSSL/include Util/include Data/include Data/MySQL/include Data/SQLite/include Data/ODBC/include Zip/include Crypto/include Web/include JSON/include MongoDB/include PDF/include SevenZip/include)
include(CheckTypeSize)
find_package(Cygwin)
#include(CMakeDetermineCompilerId)
# OS Detection
if(CMAKE_SYSTEM MATCHES "Windows")
if(WIN32)
add_definitions( -DPOCO_OS_FAMILY_WINDOWS -DUNICODE -D_UNICODE)
#set(SYSLIBS iphlpapi gdi32 odbc32)
endif(WIN32)
add_definitions( -DPOCO_OS_FAMILY_WINDOWS)
set(SYSLIBS iphlpapi gdi32 odbc32)
if (CMAKE_C_COMPILER_ID MATCHES "MSVC")
message(STATUS "XXX: MS Visual Compiler detected")
endif (CMAKE_C_COMPILER_ID MATCHES "MSVC")
endif(CMAKE_SYSTEM MATCHES "Windows")
if (CMAKE_SYSTEM MATCHES "Linux" AND NOT ANDROID )
if (UNIX AND NOT ANDROID )
add_definitions( -DPOCO_OS_FAMILY_UNIX )
# Standard 'must be' defines
add_definitions( -D_XOPEN_SOURCE=500 -D_REENTRANT -D_THREAD_SAFE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64)
set(SYSLIBS pthread dl rt)
endif(CMAKE_SYSTEM MATCHES "Linux" AND NOT ANDROID )
endif(UNIX AND NOT ANDROID )
if (CMAKE_SYSTEM MATCHES "SunOS")
add_definitions( -DPOCO_OS_FAMILY_UNIX )
@ -150,15 +145,15 @@ if (CMAKE_SYSTEM MATCHES "SunOS")
endif(CMAKE_SYSTEM MATCHES "SunOS")
if (CMAKE_COMPILER_IS_MINGW)
add_definitions(-DWC_NO_BEST_FIT_CHARS=0x400 -DPOCO_WIN32_UTF8)
add_definitions(-mno-cygwin -D_WIN32 -DMINGW32 -DWINVER=0x500 -DODBCVER=0x0300 -DPOCO_THREAD_STACK_SIZE -DFoundation_Config_INCLUDED )
add_definitions(-DWC_NO_BEST_FIT_CHARS=0x400 -DPOCO_WIN32_UTF8)
add_definitions(-mno-cygwin -D_WIN32 -DMINGW32 -DWINVER=0x500 -DODBCVER=0x0300 -DPOCO_THREAD_STACK_SIZE -DFoundation_Config_INCLUDED )
link_directories(/usr/local/lib /usr/lib)
include_directories(/usr/local/include /usr/include)
endif (CMAKE_COMPILER_IS_MINGW)
if (CMAKE_COMPILER_IS_CYGWIN)
if (CYGWIN)
# add_definitions(-DWC_NO_BEST_FIT_CHARS=0x400 -DPOCO_WIN32_UTF8)
endif (CMAKE_COMPILER_IS_CYGWIN)
endif (CYGWIN)
# SunPro C++
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
@ -170,10 +165,14 @@ if (IOS)
add_definitions( -DPOCO_HAVE_IPv6 -DPOCO_NO_FPENVIRONMENT -DPOCO_NO_STAT64 -DPOCO_NO_SHAREDLIBS -DPOCO_NO_NET_IFTYPES )
endif(IOS)
#ANDROID
#Android
if (ANDROID)
add_definitions( -DPOCO_ANDROID -DPOCO_NO_FPENVIRONMENT -DPOCO_NO_WSTRING -DPOCO_NO_SHAREDMEMORY )
endif()
endif(ANDROID)
# Collect the built libraries and include dirs, the will be used to create the PocoConfig.cmake file
set(Poco_COMPONENTS "")
if (ENABLE_TESTS)
add_subdirectory(CppUnit)
@ -182,43 +181,62 @@ endif ()
add_subdirectory(Foundation)
if(ENABLE_XML)
add_subdirectory(XML)
list(APPEND Poco_COMPONENTS "XML")
endif()
if(ENABLE_JSON)
add_subdirectory(JSON)
list(APPEND Poco_COMPONENTS "JSON")
endif()
if(ENABLE_MONGODB)
add_subdirectory(MongoDB)
list(APPEND Poco_COMPONENTS "MongoDB")
endif()
if(ENABLE_PDF)
add_subdirectory(PDF)
list(APPEND Poco_COMPONENTS "PDF")
endif()
if(ENABLE_UTIL)
add_subdirectory(Util)
list(APPEND Poco_COMPONENTS "Util")
endif()
if(ENABLE_NET)
add_subdirectory(Net)
list(APPEND Poco_COMPONENTS "Net")
endif()
# OPENSSL_SSL_LIBRARY
#NetSSL
if(WIN32 AND ENABLE_NETSSL_WIN)
add_subdirectory(NetSSL_Win)
list(APPEND Poco_COMPONENTS "NetSSL_Win")
endif(WIN32 AND ENABLE_NETSSL_WIN)
find_package(OpenSSL)
if(OPENSSL_FOUND)
include_directories("${OPENSSL_INCLUDE_DIR}")
if(ENABLE_NETSSL)
add_subdirectory(NetSSL_OpenSSL)
list(APPEND Poco_COMPONENTS "NetSSL_OpenSSL")
endif()
if(ENABLE_CRYPTO)
add_subdirectory(Crypto)
list(APPEND Poco_COMPONENTS "Crypto")
endif()
endif(OPENSSL_FOUND)
if(ENABLE_DATA)
add_subdirectory(Data)
list(APPEND Poco_COMPONENTS "Data")
endif()
if(ENABLE_SEVENZIP)
add_subdirectory(SevenZip)
list(APPEND Poco_COMPONENTS "SevenZip")
endif()
if(ENABLE_ZIP)
add_subdirectory(Zip)
list(APPEND Poco_COMPONENTS "Zip")
endif()
find_package(APR)
@ -227,6 +245,7 @@ if(APRUTIL_FOUND AND APACHE_FOUND)
include_directories( "${APACHE_INCLUDE_DIR}" "${APRUTIL_INCLUDE_DIR}" )
if(ENABLE_APACHECONNECTOR)
add_subdirectory(ApacheConnector)
list(APPEND Poco_COMPONENTS "ApacheConnector")
endif()
endif(APRUTIL_FOUND AND APACHE_FOUND)
@ -253,9 +272,38 @@ set(CPACK_PACKAGE_INSTALL_DIRECTORY "/usr/local")
include(CPack)
#############################################################
# cmake config files
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
configure_file(cmake/${PROJECT_NAME}Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake" @ONLY)
install(
FILES
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION
"lib/cmake/${PROJECT_NAME}"
COMPONENT
Devel
)
# in tree build settings
#configure_file(PocoBuildTreeSettings.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/PocoBuildTreeSettings.cmake @ONLY)
message(STATUS "CMake ${CMAKE_VERSION} successfully configured ${PROJECT_NAME} using ${CMAKE_GENERATOR} generator")
message(STATUS "Installation target path: ${CMAKE_INSTALL_PREFIX}")
message(STATUS "C_FLAGS: =${CMAKE_C_FLAGS}")
message(STATUS "CXX_FLAGS:=${CMAKE_CXX_FLAGS}")
foreach(component ${Poco_COMPONENTS})
message(STATUS "Building: ${component}")
endforeach()

12
CppUnit/CMakeLists.txt
View File

@ -8,12 +8,18 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION "1" SOVERSION "1"
DEFINE_SYMBOL CppUnit_EXPORTS)
target_link_libraries( ${LIBNAME} )
target_link_libraries( "${LIBNAME}" )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
if(WIN32)
add_subdirectory(WinTestRunner)

16
CppUnit/WinTestRunner/CMakeLists.txt
View File

@ -13,15 +13,21 @@ POCO_HEADERS_AUTO( WIN_SRCS ${HDRS_G})
# TODO: Is this flag always required?
add_definitions("-D_AFXDLL")
#TODO: Use instead of the flag above: find_package(MFC)
include_directories( "src" )
add_library( ${LIBNAME} ${LIB_MODE} ${WIN_SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${WIN_SRCS} )
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION "1" SOVERSION "1"
DEFINE_SYMBOL WinTestRunner_EXPORTS)
target_link_libraries( ${LIBNAME} CppUnit )
target_link_libraries( "${LIBNAME}" CppUnit )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
if(WIN32)
target_link_libraries( ${LIBNAME} winmm )
endif(WIN32)

31
Crypto/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoCrypto")
set(LIBNAME "Crypto")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,29 +9,41 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_definitions(-D_USRDLL)
include_directories( "include" )
#add_definitions(-D_USRDLL)
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
PROPERTIES
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL Crypto_EXPORTS)
target_link_libraries( ${LIBNAME} PocoFoundation ${OPENSSL_LIBRARIES} )
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Crypto_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation ${OPENSSL_LIBRARIES} )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

4
Crypto/cmake/PocoCryptoConfig.cmake Normal file
View File

@ -0,0 +1,4 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
include("${CMAKE_CURRENT_LIST_DIR}/PocoCryptoTargets.cmake")

46
Data/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoData")
set(LIBNAME "Data")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -17,29 +18,45 @@ if(MSVC AND NOT(MSVC_VERSION LESS 1400))
PROPERTIES COMPILE_FLAGS "/bigobj")
endif()
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL Data_EXPORTS)
target_link_libraries( ${LIBNAME} PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Data_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if(ENABLE_DATA_SQLITE)
# SQlite3 is built in any case
add_subdirectory( SQLite )
endif(ENABLE_DATA_SQLITE)
if(ENABLE_DATA_MYSQL)
find_package(MySQL)
if(MYSQL_FOUND)
include_directories("${MYSQL_INCLUDE_DIR}")
@ -48,21 +65,24 @@ if(MYSQL_FOUND)
else()
message(STATUS "MySQL Support Disabled - no MySQL library")
endif(MYSQL_FOUND)
endif(ENABLE_DATA_MYSQL)
if(ENABLE_DATA_ODBC)
find_package(ODBC)
if(CMAKE_SYSTEM MATCHES "Windows")
set(ODBC_LIBRARIES "")
if(WIN32 AND NOT WINCE)
set(ODBC_LIBRARIES "odbc32" "odbccp32")
message(STATUS "Windows native ODBC Support Enabled")
add_subdirectory( ODBC )
else ()
if (ODBC_FOUND)
else(WIN32 AND NOT WINCE)
if(ODBC_FOUND)
include_directories("${ODBC_INCLUDE_DIRECTORIES}")
message(STATUS "ODBC Support Enabled")
add_subdirectory( ODBC )
else ()
else()
message(STATUS "ODBC Support Disabled - no ODBC runtime")
endif ()
endif()
endif()
endif(WIN32 AND NOT WINCE)
endif(ENABLE_DATA_ODBC)
if (ENABLE_TESTS)
add_subdirectory(samples)

28
Data/MySQL/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoDataMySQL")
set(LIBNAME "DataMySQL")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -10,28 +11,39 @@ POCO_HEADERS_AUTO( MYSQL_SRCS ${HDRS_G})
add_definitions(-DTHREADSAFE -DNO_TCL)
include_directories( "include" )
add_library( ${LIBNAME} ${LIB_MODE} ${MYSQL_SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${MYSQL_SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL MySQL_EXPORTS)
target_link_libraries( ${LIBNAME} PocoData PocoFoundation ${MYSQL_LIB})
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL MySQL_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation Data ${MYSQL_LIB})
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(testsuite)
endif ()

5
Data/MySQL/cmake/PocoDataMySQLConfig.cmake Normal file
View File

@ -0,0 +1,5 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoData)
include("${CMAKE_CURRENT_LIST_DIR}/PocoDataMySQLTargets.cmake")

32
Data/ODBC/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoDataODBC")
set(LIBNAME "DataODBC")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,30 +9,41 @@ POCO_SOURCES_AUTO( ODBC_SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( ODBC_SRCS ${HDRS_G})
add_definitions( ${ODBC_CFLAGS} )
add_definitions( ${ODBC_CFLAGS} -DTHREADSAFE)
include_directories( "include" )
add_library( ${LIBNAME} ${LIB_MODE} ${ODBC_SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${ODBC_SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL ODBC_EXPORTS)
target_link_libraries( ${LIBNAME} PocoData PocoFoundation ${ODBC_LIBRARIES})
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL ODBC_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation Data ${ODBC_LIBRARIES})
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(testsuite)
endif ()

5
Data/ODBC/cmake/PocoDataODBCConfig.cmake Normal file
View File

@ -0,0 +1,5 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoData)
include("${CMAKE_CURRENT_LIST_DIR}/PocoDataODBCTargets.cmake")

36
Data/SQLite/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoDataSQLite")
set(LIBNAME "DataSQLite")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,11 +9,9 @@ POCO_SOURCES_AUTO( SQLITE_SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SQLITE_SRCS ${HDRS_G})
include_directories( "include" "src" )
if (POCO_UNBUNDLED)
find_package(SQLite3)
set(DATASQLITELIBS PocoData PocoFoundation ${SQLITE3_LIBRARIES})
set(DATASQLITELIBS ${SQLITE3_LIBRARIES})
include_directories("${SQLITE3_INCLUDE_DIRS}")
else()
# sqlite3
@ -24,31 +23,48 @@ else()
src/sqlite3.h
)
set(DATASQLITELIBS PocoData PocoFoundation)
set(DATASQLITELIBS "")
endif()
if(WINCE)
add_definitions(-DSQLITE_MSVC_LOCALTIME_API)
endif(WINCE)
add_definitions(-DSQLITE_THREADSAFE=1 -DSQLITE_DISABLE_LFS -DSQLITE_OMIT_UTF16 -DSQLITE_OMIT_PROGRESS_CALLBACK -DSQLITE_OMIT_COMPLETE -DSQLITE_OMIT_TCL_VARIABLE -DSQLITE_OMIT_DEPRECATED)
add_library( ${LIBNAME} ${LIB_MODE} ${SQLITE_SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SQLITE_SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL SQLite_EXPORTS)
target_link_libraries( ${LIBNAME} ${DATASQLITELIBS} )
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL SQLite_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation Data ${DATASQLITELIBS} )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(testsuite)
endif ()

5
Data/SQLite/cmake/PocoDataSQLiteConfig.cmake Normal file
View File

@ -0,0 +1,5 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoData)
include("${CMAKE_CURRENT_LIST_DIR}/PocoDataSQLiteTargets.cmake")

4
Data/cmake/PocoDataConfig.cmake Normal file
View File

@ -0,0 +1,4 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
include("${CMAKE_CURRENT_LIST_DIR}/PocoDataTargets.cmake")

53
Foundation/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoFoundation")
set(LIBNAME "Foundation")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -15,10 +16,18 @@ POCO_HEADERS_AUTO( SRCS include/Poco/OpcomChannel.h )
POCO_SOURCES_AUTO_PLAT( SRCS UNIX src/SyslogChannel.cpp )
POCO_HEADERS_AUTO( SRCS include/Poco/SyslogChannel.h )
# For Windows CE we need to disable these
if(WINCE)
POCO_SOURCES_AUTO_PLAT( SRCS OFF
src/WindowsConsoleChannel.cpp
src/EventLogChannel.cpp
)
else()
POCO_SOURCES_AUTO_PLAT( SRCS WIN32
src/WindowsConsoleChannel.cpp
src/EventLogChannel.cpp
)
endif()
POCO_HEADERS_AUTO( SRCS
include/Poco/WindowsConsoleChannel.h
@ -90,36 +99,50 @@ else()
)
endif (POCO_UNBUNDLED)
if(CMAKE_SYSTEM MATCHES "Windows")
add_definitions( -DPCRE_STATIC)
if(WIN32)
set(SYSLIBS ${SYSLIBS} iphlpapi)
else (CMAKE_SYSTEM MATCHES "Windows")
add_definitions( -DPCRE_STATIC)
endif(CMAKE_SYSTEM MATCHES "Windows")
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS})
set_target_properties( ${LIBNAME}
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL Foundation_EXPORTS)
endif(WIN32)
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
set_target_properties( ${LIBNAME} PROPERTIES LINK_FLAGS "-library=stlport4")
set_target_properties( "${LIBNAME}" PROPERTIES LINK_FLAGS "-library=stlport4")
endif (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
target_link_libraries( ${LIBNAME} ${SYSLIBS})
# TODO: Why is this here?
add_definitions( -DPCRE_STATIC)
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS})
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${PROJECT_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Foundation_EXPORTS
)
target_link_libraries( "${LIBNAME}" ${SYSLIBS})
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory( samples )
add_subdirectory( testsuite )

1
Foundation/cmake/PocoFoundationConfig.cmake Normal file
View File

@ -0,0 +1 @@
include("${CMAKE_CURRENT_LIST_DIR}/PocoFoundationTargets.cmake")

27
JSON/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoJSON")
set(LIBNAME "JSON")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,26 +9,40 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL JSON_EXPORTS)
target_link_libraries( ${LIBNAME} PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL JSON_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

4
JSON/cmake/PocoJSONConfig.cmake Normal file
View File

@ -0,0 +1,4 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
include("${CMAKE_CURRENT_LIST_DIR}/PocoJSONTargets.cmake")

26
MongoDB/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoMongoDB")
set(LIBNAME "MongoDB")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,26 +9,39 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL MongoDB_EXPORTS)
target_link_libraries( ${LIBNAME} PocoNet PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL MongoDB_EXPORTS
)
target_link_libraries( "${LIBNAME}" Net Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

5
MongoDB/cmake/PocoMongoDBConfig.cmake Normal file
View File

@ -0,0 +1,5 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoNet)
include("${CMAKE_CURRENT_LIST_DIR}/PocoMongoDBTargets.cmake")

38
Net/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoNet")
set(LIBNAME "Net")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,31 +9,48 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
#TODO: Can WIN32 be used here?
if(CMAKE_SYSTEM MATCHES "Windows")
set(SYSLIBS ${SYSLIBS} "ws2_32.lib" "iphlpapi.lib")
endif(CMAKE_SYSTEM MATCHES "Windows")
# Windows and WindowsCE need additional libraries
if(WIN32)
if(WINCE)
set(SYSLIBS ${SYSLIBS} "ws2.lib" "iphlpapi.lib")
else()
set(SYSLIBS ${SYSLIBS} "ws2_32.lib" "iphlpapi.lib")
endif()
endif(WIN32)
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL Net_EXPORTS)
target_link_libraries( ${LIBNAME} PocoFoundation ${SYSLIBS})
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Net_EXPORTS
)
target_link_libraries( "${LIBNAME}" Foundation ${SYSLIBS})
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

4
Net/cmake/PocoNetConfig.cmake Normal file
View File

@ -0,0 +1,4 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
include("${CMAKE_CURRENT_LIST_DIR}/PocoNetTargets.cmake")

26
NetSSL_OpenSSL/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoNetSSL")
set(LIBNAME "NetSSL")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,26 +9,39 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL NetSSL_EXPORTS)
target_link_libraries( ${LIBNAME} PocoCrypto PocoNet PocoUtil PocoFoundation ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY} )
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL NetSSL_EXPORTS
)
target_link_libraries( "${LIBNAME}" Crypto Net Util Foundation ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY} )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

7
NetSSL_OpenSSL/cmake/PocoNetSSLConfig.cmake Normal file
View File

@ -0,0 +1,7 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoUtil)
find_dependency(PocoNet)
find_dependency(PocoCrypto)
include("${CMAKE_CURRENT_LIST_DIR}/PocoNetSSLTargets.cmake")

50
NetSSL_Win/CMakeLists.txt Normal file
View File

@ -0,0 +1,50 @@
set(LIBNAME "NetSSLWin")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
POCO_SOURCES_AUTO( SRCS ${SRCS_G})
# Headers
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL NetSSL_Win_EXPORTS
)
target_link_libraries( "${LIBNAME}" Net Util Foundation Crypt32.lib )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
#TODO: Looks like the samples use crypto somehow?
#add_subdirectory(samples)
#add_subdirectory(testsuite)
endif ()

6
NetSSL_Win/cmake/PocoNetSSLWinConfig.cmake Normal file
View File

@ -0,0 +1,6 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoUtil)
find_dependency(PocoNet)
include("${CMAKE_CURRENT_LIST_DIR}/PocoNetSSLWinTargets.cmake")

33
NetSSL_Win/testsuite/CMakeLists.txt Normal file
View File

@ -0,0 +1,33 @@
set(TESTUNIT "${LIBNAME}-testrunner")
# Sources
file(GLOB SRCS_G "src/*.cpp")
POCO_SOURCES_AUTO( TEST_SRCS ${SRCS_G})
# Headers
file(GLOB_RECURSE HDRS_G "src/*.h" )
POCO_HEADERS_AUTO( TEST_SRCS ${HDRS_G})
POCO_SOURCES_AUTO_PLAT( TEST_SRCS WIN32
src/WinDriver.cpp
)
POCO_SOURCES_AUTO_PLAT( TEST_SRCS WINCE
src/WinCEDriver.cpp
)
add_executable( ${TESTUNIT} ${TEST_SRCS} )
add_test(NAME ${LIBNAME} WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND ${TESTUNIT} -all)
target_link_libraries( ${TESTUNIT} PocoNetSSL PocoCrypto PocoNet PocoUtil PocoXML PocoFoundation CppUnit)
if( WIN32)
add_definitions("-D_AFXDLL")
target_link_libraries( ${TESTUNIT} WinTestRunner)
endif(WIN32)
# The test is run in the build directory. So the test data is copied there too
add_custom_command(TARGET ${TESTUNIT} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/any.pem ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/rootcert.pem ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/testrunner.xml ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTUNIT}.xml
)

27
PDF/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoPDF")
set(LIBNAME "PDF")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -110,28 +111,42 @@ POCO_SOURCES( SRCS libpng
src/pngwutil.c
)
#TODO: Can we put this with the below includes? PRIVAT eg.
include_directories( "include/Poco/PDF" ) # zip src
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL PDF_EXPORTS)
target_link_libraries( ${LIBNAME} ${SYSLIBS} PocoFoundation )
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL PDF_EXPORTS
)
target_link_libraries( "${LIBNAME}" ${SYSLIBS} Foundation )
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

4
PDF/cmake/PocoPDFConfig.cmake Normal file
View File

@ -0,0 +1,4 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
include("${CMAKE_CURRENT_LIST_DIR}/PocoPDFTargets.cmake")

28
SevenZip/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoSevenZip")
set(LIBNAME "SevenZip")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -49,28 +50,39 @@ POCO_SOURCES( SRCS 7z
# src/XzIn.c
)
include_directories( include )
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL SevenZip_EXPORTS)
target_link_libraries( ${LIBNAME} PocoUtil PocoXML PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL SevenZip_EXPORTS
)
target_link_libraries( "${LIBNAME}" Util XML Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
# TODO: Add tests

6
SevenZip/cmake/PocoSevenZipConfig.cmake Normal file
View File

@ -0,0 +1,6 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoXML)
find_dependency(PocoUtil)
include("${CMAKE_CURRENT_LIST_DIR}/PocoSevenZipTargets.cmake")

29
Util/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoUtil")
set(LIBNAME "Util")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -14,28 +15,40 @@ POCO_SOURCES_AUTO_PLAT( SRCS WIN32
src/WinService.cpp
)
include_directories( "include" )
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL Util_EXPORTS)
target_link_libraries( ${LIBNAME} PocoJSON PocoXML PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Util_EXPORTS
)
target_link_libraries( "${LIBNAME}" JSON XML Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

6
Util/cmake/PocoUtilConfig.cmake Normal file
View File

@ -0,0 +1,6 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoXML)
find_dependency(PocoJSON)
include("${CMAKE_CURRENT_LIST_DIR}/PocoUtilTargets.cmake")

34
XML/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoXML")
set(LIBNAME "XML")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -24,28 +25,47 @@ else()
)
endif (POCO_UNBUNDLED)
add_definitions(-D_USRDLL -DXML_NS -DXML_DTD -DHAVE_EXPAT_CONFIG_H)
if(WIN32)
#TODO: Is XML_STATIC only required with Windows? What does it do?
add_definitions(-DXML_STATIC -DXML_NS -DXML_DTD -DHAVE_EXPAT_CONFIG_H)
else()
add_definitions(-DXML_NS -DXML_DTD -DHAVE_EXPAT_CONFIG_H)
endif()
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL XML_EXPORTS)
target_link_libraries( ${LIBNAME} ${SYSLIBS} PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL XML_EXPORTS
)
target_link_libraries( "${LIBNAME}" ${SYSLIBS} Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

4
XML/cmake/PocoXMLConfig.cmake Normal file
View File

@ -0,0 +1,4 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
include("${CMAKE_CURRENT_LIST_DIR}/PocoXMLTargets.cmake")

26
Zip/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LIBNAME "PocoZip")
set(LIBNAME "Zip")
set(POCO_LIBNAME "Poco${LIBNAME}")
# Sources
file(GLOB SRCS_G "src/*.cpp")
@ -8,26 +9,39 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
file(GLOB_RECURSE HDRS_G "include/*.h" )
POCO_HEADERS_AUTO( SRCS ${HDRS_G})
add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
set_target_properties( ${LIBNAME}
add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
set_target_properties( "${LIBNAME}"
PROPERTIES
VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
DEFINE_SYMBOL Zip_EXPORTS)
target_link_libraries( ${LIBNAME} PocoUtil PocoXML PocoFoundation)
OUTPUT_NAME ${POCO_LIBNAME}
DEFINE_SYMBOL Zip_EXPORTS
)
target_link_libraries( "${LIBNAME}" Util XML Foundation)
target_include_directories( "${LIBNAME}"
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
install(
DIRECTORY include/Poco
DESTINATION include
COMPONENT Devel
PATTERN ".svn" EXCLUDE
)
install(
TARGETS ${LIBNAME}
TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
LIBRARY DESTINATION lib${LIB_SUFFIX}
ARCHIVE DESTINATION lib${LIB_SUFFIX}
RUNTIME DESTINATION bin
INCLUDES DESTINATION include
)
POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
if (ENABLE_TESTS)
add_subdirectory(samples)
add_subdirectory(testsuite)

6
Zip/cmake/PocoZipConfig.cmake Normal file
View File

@ -0,0 +1,6 @@
include(CMakeFindDependencyMacro)
set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
find_dependency(PocoFoundation)
find_dependency(PocoUtil)
find_dependency(PocoXML)
include("${CMAKE_CURRENT_LIST_DIR}/PocoZipTargets.cmake")

46
cmake/PocoConfig.cmake.in Normal file
View File

@ -0,0 +1,46 @@
if (CMAKE_VERSION VERSION_LESS 2.8.9)
message(FATAL_ERROR "Poco requires at least CMake version 2.8.9")
endif()
if (NOT Poco_FIND_COMPONENTS)
set(Poco_NOT_FOUND_MESSAGE "The Poco package requires at least one component")
set(Poco_FOUND False)
return()
endif()
set(_Poco_FIND_PARTS_REQUIRED)
if (Poco_FIND_REQUIRED)
set(_Poco_FIND_PARTS_REQUIRED REQUIRED)
endif()
set(_Poco_FIND_PARTS_QUIET)
if (Poco_FIND_QUIETLY)
set(_Poco_FIND_PARTS_QUIET QUIET)
endif()
get_filename_component(_Poco_install_prefix "${CMAKE_CURRENT_LIST_DIR}" ABSOLUTE)
set(_Poco_NOTFOUND_MESSAGE)
foreach(module ${Poco_FIND_COMPONENTS})
find_package(Poco${module}
${_Poco_FIND_PARTS_QUIET}
${_Poco_FIND_PARTS_REQUIRED}
PATHS "${_Poco_install_prefix}" NO_DEFAULT_PATH
)
if (NOT Poco${module}_FOUND)
if (Poco_FIND_REQUIRED_${module})
set(_Poco_NOTFOUND_MESSAGE "${_Poco_NOTFOUND_MESSAGE}Failed to find Poco component \"${module}\" config file at \"${_Poco_install_prefix}/Poco${module}/Poco${module}Config.cmake\"\n")
elseif(NOT Poco_FIND_QUIETLY)
message(WARNING "Failed to find Poco component \"${module}\" config file at \"${_Poco_install_prefix}/Poco${module}/Poco${module}Config.cmake\"")
endif()
endif()
# For backward compatibility set the LIBRARIES variable
list(APPEND Poco_LIBRARIES "Poco::${module}")
endforeach()
if (_Poco_NOTFOUND_MESSAGE)
set(Poco_NOT_FOUND_MESSAGE "${_Poco_NOTFOUND_MESSAGE}")
set(Poco_FOUND False)
endif()

11
cmake/PocoConfigVersion.cmake.in Normal file
View File

@ -0,0 +1,11 @@
set(PACKAGE_VERSION @APPLICATION_VERSION@)
# Check whether the requested PACKAGE_FIND_VERSION is compatible
if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
set(PACKAGE_VERSION_COMPATIBLE FALSE)
else()
set(PACKAGE_VERSION_COMPATIBLE TRUE)
if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
set(PACKAGE_VERSION_EXACT TRUE)
endif()
endif()