Configs changed and some hooks removed

Author: sraghu1

3rdparty/gtest/CMakeLists.txt

@@ -18,7 +18,7 @@ else()
     set(GTEST_HAS_CLONE 1)
 endif()
 
-set(GTEST_DIR ${VMF_3PTY_DIR}/gtest/fused-src)
+set(GTEST_DIR ${UMF_3PTY_DIR}/gtest/fused-src)
 
 set(GTEST_INCLUDE_DIR "${GTEST_DIR}" CACHE PATH "GTest lib include dir" )
 

3rdparty/xmp--fix-for-mac.patch

@@ -142,11 +142,11 @@ index 2f2d787..f312bb4 100644
 
  #enable_testing(true)
 
--add_subdirectory(${VMF_3PTY_DIR}/gtest)
+-add_subdirectory(${UMF_3PTY_DIR}/gtest)
 +if(BUILD_TESTS)
-+    add_subdirectory(${VMF_3PTY_DIR}/gtest)
++    add_subdirectory(${UMF_3PTY_DIR}/gtest)
 +endif()
- add_subdirectory(${VMF_3PTY_DIR}/xmp)
+ add_subdirectory(${UMF_3PTY_DIR}/xmp)
  add_subdirectory(modules)
 
 -- 

CMakeLists.txt

@@ -4,15 +4,15 @@ message(STATUS "CMake version: ${CMAKE_VERSION}")
 # must go before the `project()` command
 set(CMAKE_CONFIGURATION_TYPES "Release;Debug" CACHE STRING "Configs" FORCE)
 
-project(vmf)
+project(umf)
 
-set(VMF_3PTY_DIR ${CMAKE_SOURCE_DIR}/3rdparty)
-set(XMP_DIR ${VMF_3PTY_DIR}/xmp)
+set(UMF_3PTY_DIR ${CMAKE_SOURCE_DIR}/3rdparty)
+set(XMP_DIR ${UMF_3PTY_DIR}/xmp)
 set(MODULES_DIR ${CMAKE_SOURCE_DIR}/modules)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
 if(NOT IOS)
-  option(BUILD_SHARED_LIBS "Whether or not to build VMF as shared library" ON)
+  option(BUILD_SHARED_LIBS "Whether or not to build UMF as shared library" ON)
   option(BUILD_SAMPLES "Whether or not to build the samples" ON)
   option(BUILD_TESTS "Whether or not to build the tests" ON)
   # Java
@@ -29,9 +29,9 @@ else()
 endif()
 
 if(NOT BUILD_SHARED_LIBS AND BUILD_JAVA_API)
-  # JAR depends on dynamic VMF lib
+  # JAR depends on dynamic UMF lib
   set(BUILD_JAVA_API OFF)
-  message(WARNING "Java API building is disabled since it requires VMF lib to be dynamic")
+  message(WARNING "Java API building is disabled since it requires UMF lib to be dynamic")
 endif()
 
 if(WIN32)
@@ -60,9 +60,9 @@ endif()
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
 # The version number.
-set(VMF_VERSION_MAJOR "3")
-set(VMF_VERSION_MINOR "0")
-set(VMF_VERSION_TYPE  "RC1") # dev, alpha, beta
+set(UMF_VERSION_MAJOR "3")
+set(UMF_VERSION_MINOR "0")
+set(UMF_VERSION_TYPE  "RC1") # dev, alpha, beta
 
 # adding git info to the version if possible
 if(NOT COMMAND find_host_package)
@@ -74,67 +74,67 @@ find_host_package(Git QUIET)
 if(GIT_FOUND)
   execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
     WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-    OUTPUT_VARIABLE VMF_VERSION_VCS
+    OUTPUT_VARIABLE UMF_VERSION_VCS
     RESULT_VARIABLE GIT_RESULT
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE
   )
   if(NOT GIT_RESULT EQUAL 0)
-    set(VMF_VERSION_VCS "unknown")
+    set(UMF_VERSION_VCS "unknown")
   endif()
 else()
-  set(VMF_VERSION_VCS "unknown")
+  set(UMF_VERSION_VCS "unknown")
 endif()
 
 # reporting build settings
 
-function(vmf_status msg)
+function(umf_status msg)
   message(STATUS "${msg}")
-  file(APPEND "${VMF_BUILD_INFO_FILE}" "${msg}\n")
+  file(APPEND "${umf_build_info_FILE}" "${msg}\n")
 endfunction()
 
-set(VMF_BUILD_INFO_FILE "${CMAKE_BINARY_DIR}/build-info.tmp")
-file(REMOVE "${VMF_BUILD_INFO_FILE}")
-file(APPEND "${VMF_BUILD_INFO_FILE}" "const char* vmf_build_info = R\"vmf_build_info(\n")
+set(umf_build_info_FILE "${CMAKE_BINARY_DIR}/build-info.tmp")
+file(REMOVE "${umf_build_info_FILE}")
+file(APPEND "${umf_build_info_FILE}" "const char* umf_build_info = R\"umf_build_info(\n")
 
-message(STATUS "*** VMF build configuration ***")
-# VMF
-vmf_status("    VMF version: ${VMF_VERSION_MAJOR}.${VMF_VERSION_MINOR}.${VMF_VERSION_TYPE} (GIT: ${VMF_VERSION_VCS})")
+message(STATUS "*** UMF build configuration ***")
+# UMF
+umf_status("    UMF version: ${UMF_VERSION_MAJOR}.${UMF_VERSION_MINOR}.${UMF_VERSION_TYPE} (GIT: ${UMF_VERSION_VCS})")
 # OS, HW
-vmf_status("    Platform:")
-vmf_status("      Host: ${CMAKE_HOST_SYSTEM} ${CMAKE_HOST_SYSTEM_PROCESSOR}")
+umf_status("    Platform:")
+umf_status("      Host: ${CMAKE_HOST_SYSTEM} ${CMAKE_HOST_SYSTEM_PROCESSOR}")
 if(CMAKE_CROSSCOMPILING)
-  vmf_status("      Target: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR}")
+  umf_status("      Target: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR}")
 endif()
 if(ANDROID)
-  vmf_status("        Android native API level: android-${ANDROID_NATIVE_API_LEVEL} (${ANDROID_ABI})")
-  vmf_status("        NDK Toolchain: ${ANDROID_TOOLCHAIN_NAME} (NDK ${ANDROID_NDK_RELEASE}, ${ANDROID_NDK})")
+  umf_status("        Android native API level: android-${ANDROID_NATIVE_API_LEVEL} (${ANDROID_ABI})")
+  umf_status("        NDK Toolchain: ${ANDROID_TOOLCHAIN_NAME} (NDK ${ANDROID_NDK_RELEASE}, ${ANDROID_NDK})")
 endif()
 # tools
-vmf_status("    CMake generator: ${CMAKE_GENERATOR}")
-set(VMF_COMPILER_STR "(${CMAKE_CXX_COMPILER_ID}")
+umf_status("    CMake generator: ${CMAKE_GENERATOR}")
+set(UMF_COMPILER_STR "(${CMAKE_CXX_COMPILER_ID}")
 if(CMAKE_CXX_COMPILER_VERSION)
-  set(VMF_COMPILER_STR "${VMF_COMPILER_STR} ${CMAKE_CXX_COMPILER_VERSION}")
+  set(UMF_COMPILER_STR "${UMF_COMPILER_STR} ${CMAKE_CXX_COMPILER_VERSION}")
 elseif(CMAKE_COMPILER_IS_CLANGCXX)
-  set(VMF_COMPILER_STR "${VMF_COMPILER_STR} ${CMAKE_CLANG_REGEX_VERSION}")
+  set(UMF_COMPILER_STR "${UMF_COMPILER_STR} ${CMAKE_CLANG_REGEX_VERSION}")
 elseif(CMAKE_COMPILER_IS_GNUCXX)
-  set(VMF_COMPILER_STR "${VMF_COMPILER_STR} ${CMAKE_GCC_REGEX_VERSION}")
+  set(UMF_COMPILER_STR "${UMF_COMPILER_STR} ${CMAKE_GCC_REGEX_VERSION}")
 endif()
-set(VMF_COMPILER_STR "${VMF_COMPILER_STR}) ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
-string(STRIP "${VMF_COMPILER_STR}" VMF_COMPILER_STR)
-vmf_status("    CMake C++ compiler: ${VMF_COMPILER_STR}")
-vmf_status("    CMake Linker: ${CMAKE_LINKER}")
-vmf_status("    CMake build tool: ${CMAKE_BUILD_TOOL}")
+set(UMF_COMPILER_STR "${UMF_COMPILER_STR}) ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1}")
+string(STRIP "${UMF_COMPILER_STR}" UMF_COMPILER_STR)
+umf_status("    CMake C++ compiler: ${UMF_COMPILER_STR}")
+umf_status("    CMake Linker: ${CMAKE_LINKER}")
+umf_status("    CMake build tool: ${CMAKE_BUILD_TOOL}")
 if(Java_JAVAC_EXECUTABLE)
-  vmf_status("    CMake Java compiler: ${Java_JAVAC_EXECUTABLE} (ver ${Java_VERSION})")
+  umf_status("    CMake Java compiler: ${Java_JAVAC_EXECUTABLE} (ver ${Java_VERSION})")
 endif()
 if(NOT CMAKE_GENERATOR MATCHES "Xcode|Visual Studio")
   message(STATUS "    CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 else()
   message(STATUS "    CMAKE_CONFIGURATION_TYPES: ${CMAKE_CONFIGURATION_TYPES}")
 endif()
 # build options
-vmf_status("    BUILD_SHARED_LIBS: ${BUILD_SHARED_LIBS}")
+umf_status("    BUILD_SHARED_LIBS: ${BUILD_SHARED_LIBS}")
 message(STATUS "    BUILD_SAMPLES: ${BUILD_SAMPLES}")
 message(STATUS "    BUILD_QT_SAMPLES: ${BUILD_QT_SAMPLES}")
 message(STATUS "    BUILD_TESTS: ${BUILD_TESTS}")
@@ -144,7 +144,7 @@ else()
   message(STATUS "    BUILD_JAVA_API: OFF")
 endif()
 if(CMAKE_COMPILER_IS_GNUCXX)
-  vmf_status("    CODE_COVERAGE: ${CODE_COVERAGE}")
+  umf_status("    CODE_COVERAGE: ${CODE_COVERAGE}")
 endif()
 
 #if(WIN32)
@@ -182,30 +182,30 @@ else()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
 endif()
 
-file(APPEND "${VMF_BUILD_INFO_FILE}" "    CMake version = ${CMAKE_VERSION}\n")
-file(APPEND "${VMF_BUILD_INFO_FILE}" ")vmf_build_info\";\n")
-execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${VMF_BUILD_INFO_FILE}" "${CMAKE_BINARY_DIR}/build-info.inc" OUTPUT_QUIET)
+file(APPEND "${umf_build_info_FILE}" "    CMake version = ${CMAKE_VERSION}\n")
+file(APPEND "${umf_build_info_FILE}" ")umf_build_info\";\n")
+execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${umf_build_info_FILE}" "${CMAKE_BINARY_DIR}/build-info.inc" OUTPUT_QUIET)
 message(STATUS "*** *** ***")
 
 #enable_testing(true)
 
 if(BUILD_TESTS)
-    add_subdirectory(${VMF_3PTY_DIR}/gtest)
+    add_subdirectory(${UMF_3PTY_DIR}/gtest)
 endif()
-add_subdirectory(${VMF_3PTY_DIR}/xmp)
-add_subdirectory(${VMF_3PTY_DIR}/libxml2)
-add_subdirectory(${VMF_3PTY_DIR}/libjson)
-add_subdirectory(${VMF_3PTY_DIR}/cryptopp)
+add_subdirectory(${UMF_3PTY_DIR}/xmp)
+add_subdirectory(${UMF_3PTY_DIR}/libxml2)
+add_subdirectory(${UMF_3PTY_DIR}/libjson)
+add_subdirectory(${UMF_3PTY_DIR}/cryptopp)
 add_subdirectory(modules)
 
 if(BUILD_SAMPLES)
     set(CMAKE_DISABLE_FIND_PACKAGE_VMF TRUE)
-    set(VMF_LIB_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
-    set(VMF_LIBS vmf)
-    set(VMF_INCLUDE_DIR "${MODULES_DIR}/vmfcore/include" "${CMAKE_BINARY_DIR}")
-    set(VMF_DATA_DIR "${CMAKE_SOURCE_DIR}/data")
+    set(UMF_LIB_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+    set(UMF_LIBS umf)
+    set(UMF_INCLUDE_DIR "${MODULES_DIR}/umfcore/include" "${CMAKE_BINARY_DIR}")
+    set(UMF_DATA_DIR "${CMAKE_SOURCE_DIR}/data")
     if(BUILD_JAVA_API)
-      set(VMF_JAR_PATH "${CMAKE_BINARY_DIR}/bin/vmf_java.jar")
+      set(UMF_JAR_PATH "${CMAKE_BINARY_DIR}/bin/umf_java.jar")
     endif()
     add_subdirectory(samples)
 endif()
@@ -223,17 +223,17 @@ if(NOT ANDROID)
 endif()
 
 if (BUILD_INSTALLER)
-    set(CPACK_PACKAGE_NAME "Intel VMF SDK")
+    set(CPACK_PACKAGE_NAME "Intel UMF SDK")
     set(CPACK_PACKAGE_VENDOR "Intel")
-    set(CPACK_PACKAGE_VERSION "${VMF_VERSION_MAJOR}.${VMF_VERSION_MINOR}")
-    set(CPACK_PACKAGE_VERSION_MAJOR ${VMF_VERSION_MAJOR})
-    set(CPACK_PACKAGE_VERSION_MINOR ${VMF_VERSION_MINOR})
+    set(CPACK_PACKAGE_VERSION "${UMF_VERSION_MAJOR}.${UMF_VERSION_MINOR}")
+    set(CPACK_PACKAGE_VERSION_MAJOR ${UMF_VERSION_MAJOR})
+    set(CPACK_PACKAGE_VERSION_MINOR ${UMF_VERSION_MINOR})
     set(CPACK_PACKAGE_VERSION_PATCH "0")
-    set(CPACK_PACKAGE_FILE_NAME "Intel-VMF-SDK-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
-    if(VMF_VERSION_TYPE)
-        set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-${VMF_VERSION_TYPE}")
+    set(CPACK_PACKAGE_FILE_NAME "Intel-UMF-SDK-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
+    if(UMF_VERSION_TYPE)
+        set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-${UMF_VERSION_TYPE}")
     endif()
-    set(CPACK_PACKAGE_INSTALL_DIRECTORY "Intel-VMF-SDK-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
+    set(CPACK_PACKAGE_INSTALL_DIRECTORY "Intel-UMF-SDK-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
     set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
     set(CPACK_GENERATOR "WIX")
     set(CPACK_WIX_PRODUCT_GUID "F05416DA-303D-4952-BEF4-D576AE4F4A3A")
@@ -273,7 +273,7 @@ if (BUILD_INSTALLER)
     install(FILES "cmake/FindVMF.cmake" DESTINATION "samples")
 
 if (BUILD_JAVA_API)	
-    install(FILES "${CMAKE_BINARY_DIR}/bin/vmf_java.jar" DESTINATION "java")
+    install(FILES "${CMAKE_BINARY_DIR}/bin/umf_java.jar" DESTINATION "java")
 endif()
 
 # documentation

appveyor.yml

@@ -29,6 +29,6 @@ build_script:
 on_success:
   - bin\%CONFIGURATION%\unit-tests.exe
   - bin\%CONFIGURATION%\unit-tests-ds.exe
-  - if exist bin\\vmf_java.jar (cd bin && java -Djava.library.path=%CONFIGURATION% -cp .;vmf_java.jar;vmf_java_test.jar;junit-4.11.jar org.junit.runner.JUnitCore VmfTestSuite)
+  - if exist bin\\umf_java.jar (cd bin && java -Djava.library.path=%CONFIGURATION% -cp .;umf_java.jar;umf_java_test.jar;junit-4.11.jar org.junit.runner.JUnitCore VmfTestSuite)
 
 test: off

cmake/FindVMF.cmake

@@ -2,20 +2,20 @@
 # Implements FIND_PACKAGE(VMF) call in 'Module' mode
 #
 # Use the following CMake code in your CMakeLists.txt:
-# # provide path to the VMF SDK installation dir via 'VMF_DIR' variable (-DVMF_DIR=C:\Intel-VMF-SDK-1.0)
+# # provide path to the VMF SDK installation dir via 'UMF_DIR' variable (-DUMF_DIR=C:\Intel-VMF-SDK-1.0)
 # SET(VMF_STATIC ON) # or 'OFF'
 # FIND_PACKAGE(VMF)
-# INCLUDE_DIRECTORIES(${VMF_INCLUDE_DIR})
-# LINK_DIRECTORIES(${VMF_LIB_DIR})
-# TARGET_LINK_LIBRARIES(your_target ${VMF_LIBS})
+# INCLUDE_DIRECTORIES(${UMF_INCLUDE_DIR})
+# LINK_DIRECTORIES(${UMF_LIB_DIR})
+# TARGET_LINK_LIBRARIES(your_target ${UMF_LIBS})
 #
 #    The successful 'FIND_PACKAGE(VMF)' call defines the following variables:
-#      - VMF_LIBS                  : The list of libraries to links against.
-#      - VMF_LIB_DIR               : The directory where VMF lib files are. (Use for 'LINK_DIRECTORIES' call.)
-#      - VMF_INCLUDE_DIR           : The VMF include directory.
-#      - VMF_BIN_DIR               : The VMF binaries directory.
-#      - VMF_DATA_DIR              : The VMF data directory.
-#      - VMF_JAR_PATH              : The VMF data directory.
+#      - UMF_LIBS                  : The list of libraries to links against.
+#      - UMF_LIB_DIR               : The directory where VMF lib files are. (Use for 'LINK_DIRECTORIES' call.)
+#      - UMF_INCLUDE_DIR           : The VMF include directory.
+#      - UMF_BIN_DIR               : The VMF binaries directory.
+#      - UMF_DATA_DIR              : The VMF data directory.
+#      - UMF_JAR_PATH              : The VMF data directory.
 
 
 # use static lib unless dynamic is forced via VMF_STATIC or BUILD_SHARED_LIBS
@@ -27,31 +27,31 @@ if(NOT DEFINED VMF_STATIC)
   endif()
 endif()
 
-if(NOT DEFINED VMF_DIR AND DEFINED ENV{VMF_DIR})
-  set(VMF_DIR "$ENV{VMF_DIR}")
+if(NOT DEFINED UMF_DIR AND DEFINED ENV{UMF_DIR})
+  set(UMF_DIR "$ENV{UMF_DIR}")
 endif()
 
-if(NOT DEFINED VMF_DIR)
+if(NOT DEFINED UMF_DIR)
   if(EXISTS "${CMAKE_SOURCE_DIR}/../include/vmf/vmf.hpp")
-    set(VMF_DIR "${CMAKE_SOURCE_DIR}/..")
+    set(UMF_DIR "${CMAKE_SOURCE_DIR}/..")
   else()
-    message(FATAL_ERROR "[FindVMF] Can't find VMF. Please specify VMF_DIR to fix.")
+    message(FATAL_ERROR "[FindVMF] Can't find VMF. Please specify UMF_DIR to fix.")
   endif()
 endif()
 
-set(VMF_LIBS debug vmfd optimized vmf)
-set(VMF_DATA_DIR "${VMF_DIR}/data")
-set(VMF_INCLUDE_DIR "${VMF_DIR}/include")
-set(VMF_LIB_DIR  "${VMF_DIR}")
-set(VMF_BIN_DIR  "${VMF_DIR}")
+set(UMF_LIBS debug vmfd optimized vmf)
+set(UMF_DATA_DIR "${UMF_DIR}/data")
+set(UMF_INCLUDE_DIR "${UMF_DIR}/include")
+set(UMF_LIB_DIR  "${UMF_DIR}")
+set(UMF_BIN_DIR  "${UMF_DIR}")
 
 if(${CMAKE_SIZEOF_VOID_P} EQUAL 8)
   set(ARCH_DIR "x64")
 else()
   set(ARCH_DIR "x86")
 endif()
-set(VMF_LIB_DIR  "${VMF_LIB_DIR}/${ARCH_DIR}")
-set(VMF_BIN_DIR  "${VMF_BIN_DIR}/${ARCH_DIR}")
+set(UMF_LIB_DIR  "${UMF_LIB_DIR}/${ARCH_DIR}")
+set(UMF_BIN_DIR  "${UMF_BIN_DIR}/${ARCH_DIR}")
 
 if(MSVC)
   if(MSVC_VERSION EQUAL 1600)
@@ -63,29 +63,29 @@ if(MSVC)
   else()
     message(FATAL_ERROR "[FindVMF] Unsupported MSVS version. Only MSVS 2010 (vc10), 2012 (vc11) and 2013 (vc12) are supported.")
   endif()
-  set(VMF_LIB_DIR  "${VMF_LIB_DIR}/${RUNTIME_SUBDIR}")
-  set(VMF_BIN_DIR  "${VMF_BIN_DIR}/${RUNTIME_SUBDIR}")
+  set(UMF_LIB_DIR  "${UMF_LIB_DIR}/${RUNTIME_SUBDIR}")
+  set(UMF_BIN_DIR  "${UMF_BIN_DIR}/${RUNTIME_SUBDIR}")
 endif()
 
 if(VMF_STATIC)
-  set(VMF_LIB_DIR  "${VMF_LIB_DIR}/static-lib")
+  set(UMF_LIB_DIR  "${UMF_LIB_DIR}/static-lib")
 else()
-  set(VMF_LIB_DIR  "${VMF_LIB_DIR}/lib")
+  set(UMF_LIB_DIR  "${UMF_LIB_DIR}/lib")
 endif()
-set(VMF_BIN_DIR  "${VMF_BIN_DIR}/bin")
+set(UMF_BIN_DIR  "${UMF_BIN_DIR}/bin")
 
-if(EXISTS "${VMF_INCLUDE_DIR}/vmf/vmf.hpp" AND EXISTS "${VMF_LIB_DIR}")
+if(EXISTS "${UMF_INCLUDE_DIR}/vmf/vmf.hpp" AND EXISTS "${UMF_LIB_DIR}")
   set(VMF_FOUND YES)
-  message(STATUS "[FindVMF] Using VMF libs from ${VMF_LIB_DIR}")
+  message(STATUS "[FindVMF] Using VMF libs from ${UMF_LIB_DIR}")
 else()
   set(VMF_FOUND NO)
-  message(FATAL_ERROR "[FindVMF] VMF SDK files are absent at '${VMF_INCLUDE_DIR}' or '${VMF_LIB_DIR}'")
+  message(FATAL_ERROR "[FindVMF] VMF SDK files are absent at '${UMF_INCLUDE_DIR}' or '${UMF_LIB_DIR}'")
 endif()
 
-if(EXISTS "${VMF_DIR}/java/vmf_java.jar")
-  set(VMF_JAR_PATH "${VMF_DIR}/java/vmf_java.jar")
+if(EXISTS "${UMF_DIR}/java/umf_java.jar")
+  set(UMF_JAR_PATH "${UMF_DIR}/java/umf_java.jar")
 endif()
 
 if(VMF_FOUND AND WIN32 AND NOT VMF_STATIC)
-  message(STATUS "[FindVMF] Consider adding '${VMF_BIN_DIR}' to PATH before running your application.")
+  message(STATUS "[FindVMF] Consider adding '${UMF_BIN_DIR}' to PATH before running your application.")
 endif()

codecov.yml

@@ -7,5 +7,5 @@ coverage:
   - CMakeFiles/.*
   - test/.*
   - modules/vmdatasource/test/.*
-  - modules/vmfcore/test/.*
+  - modules/umfcore/test/.*
   - usr/lib/.*