hpp-tutorial 9.0.0__0-py3-none-any.whl

cmeel.prefix/include/hpp/tutorial/config.hh

@@ -0,0 +1,94 @@
+/*
+ * This file has been automatically generated by the jrl-cmakemodules.
+ * Please see https://github.com/jrl-umi3218/jrl-cmakemodules/blob/master/config.hh.cmake for details.
+*/
+
+#ifndef HPP_TUTORIAL_CONFIG_HH
+# define HPP_TUTORIAL_CONFIG_HH
+
+// Package version (header).
+# define HPP_TUTORIAL_VERSION_UNKNOWN_TAG 0 // Used to mention that the current version is unknown.
+# define HPP_TUTORIAL_VERSION "9.0.0"
+# define HPP_TUTORIAL_MAJOR_VERSION 9
+# define HPP_TUTORIAL_MINOR_VERSION 0
+# define HPP_TUTORIAL_PATCH_VERSION 0
+
+#define HPP_TUTORIAL_VERSION_AT_LEAST(major, minor, patch) (HPP_TUTORIAL_MAJOR_VERSION>major || (HPP_TUTORIAL_MAJOR_VERSION>=major && \
+                                                             (HPP_TUTORIAL_MINOR_VERSION>minor || (HPP_TUTORIAL_MINOR_VERSION>=minor && \
+                                                                                                     HPP_TUTORIAL_PATCH_VERSION>=patch))))
+
+#define HPP_TUTORIAL_VERSION_AT_MOST(major, minor, patch) (HPP_TUTORIAL_MAJOR_VERSION<major || (HPP_TUTORIAL_MAJOR_VERSION<=major && \
+                                                            (HPP_TUTORIAL_MINOR_VERSION<minor || (HPP_TUTORIAL_MINOR_VERSION<=minor && \
+                                                                                                     HPP_TUTORIAL_PATCH_VERSION<=patch))))
+
+// Handle portable symbol export.
+// Defining manually which symbol should be exported is required
+// under Windows whether MinGW or MSVC is used.
+//
+// The headers then have to be able to work in two different modes:
+// - dllexport when one is building the library,
+// - dllimport for clients using the library.
+//
+// On Linux, set the visibility accordingly. If C++ symbol visibility
+// is handled by the compiler, see: http://gcc.gnu.org/wiki/Visibility
+//
+// Explicit template instantiation on Windows need to add
+// dllexport on the definition and dllimport on the declaration.
+// The XXX_EXPLICIT_INSTANTIATION_DECLARATION_DLLAPI macro
+// should be set on the declaration while
+// the XXX_EXPLICIT_INSTANTIATION_DEFINITION_DLLAPI macro
+// should be set on the definition.
+# if defined _WIN32 || defined __CYGWIN__
+// On Microsoft Windows, use dllimport and dllexport to tag symbols.
+#  define HPP_TUTORIAL_DLLIMPORT __declspec(dllimport)
+#  define HPP_TUTORIAL_DLLEXPORT __declspec(dllexport)
+#  define HPP_TUTORIAL_DLLLOCAL
+#  define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLIMPORT __declspec(dllimport)
+#  define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLEXPORT
+#  define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLIMPORT __declspec(dllimport)
+#  define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLEXPORT __declspec(dllexport)
+# else
+// On Linux, for GCC >= 4, tag symbols using GCC extension.
+#  if __GNUC__ >= 4
+#   define HPP_TUTORIAL_DLLIMPORT __attribute__ ((visibility("default")))
+#   define HPP_TUTORIAL_DLLEXPORT __attribute__ ((visibility("default")))
+#   define HPP_TUTORIAL_DLLLOCAL  __attribute__ ((visibility("hidden")))
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLIMPORT __attribute__ ((visibility("default")))
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLEXPORT __attribute__ ((visibility("default")))
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLIMPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLEXPORT
+#  else
+// Otherwise (GCC < 4 or another compiler is used), export everything.
+#   define HPP_TUTORIAL_DLLIMPORT
+#   define HPP_TUTORIAL_DLLEXPORT
+#   define HPP_TUTORIAL_DLLLOCAL
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLIMPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLEXPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLIMPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLEXPORT
+#  endif // __GNUC__ >= 4
+# endif // defined _WIN32 || defined __CYGWIN__
+
+# ifdef HPP_TUTORIAL_STATIC
+// If one is using the library statically, get rid of
+// extra information and use standard explicit template
+// instantiation keyword.
+#  define HPP_TUTORIAL_DLLAPI
+#  define HPP_TUTORIAL_LOCAL
+#  define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION extern template
+# else
+// Depending on whether one is building or using the
+// library define DLLAPI to import or export and
+// define the right explicit template instantiation keyword.
+#  ifdef hpp_tutorial_EXPORTS
+#   define HPP_TUTORIAL_DLLAPI HPP_TUTORIAL_DLLEXPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLAPI HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLEXPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLAPI HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLEXPORT
+#  else
+#   define HPP_TUTORIAL_DLLAPI HPP_TUTORIAL_DLLIMPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLAPI HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DECLARATION_DLLIMPORT
+#   define HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLAPI HPP_TUTORIAL_EXPLICIT_INSTANTIATION_DEFINITION_DLLIMPORT
+#  endif // HPP_TUTORIAL_EXPORTS
+#  define HPP_TUTORIAL_LOCAL HPP_TUTORIAL_DLLLOCAL
+# endif // HPP_TUTORIAL_STATIC
+#endif //! HPP_TUTORIAL_CONFIG_HH

cmeel.prefix/include/hpp/tutorial/deprecated.hh

@@ -0,0 +1,56 @@
+/*
+ * This file has been automatically generated by the jrl-cmakemodules.
+ * Please see https://github.com/jrl-umi3218/jrl-cmakemodules/blob/master/deprecated.hh.cmake for details.
+*/
+
+#ifndef HPP_TUTORIAL_DEPRECATED_HH
+# define HPP_TUTORIAL_DEPRECATED_HH
+
+// Define a suffix which can be used to tag a type, a function or a a
+// variable as deprecated (i.e. it will emit a warning when using it).
+//
+// Tagging a function as deprecated:
+//  void foo () HPP_TUTORIAL_DEPRECATED;
+//
+// Tagging a type as deprecated:
+//  class Foo {};
+//  typedef Foo Bar HPP_TUTORIAL_DEPRECATED;
+//
+// Tagging a variable as deprecated:
+//  int a HPP_TUTORIAL_DEPRECATED = 0;
+//
+// The use of a macro is required as this is /not/ a standardized
+// feature of C++ language or preprocessor, even if most of the
+// compilers support it.
+# if defined(__cplusplus) && (__cplusplus >= 201402L)
+#  define HPP_TUTORIAL_DEPRECATED [[deprecated]]
+#  define HPP_TUTORIAL_DEPRECATED_MESSAGE(message) [[deprecated(#message)]]
+# elif defined(__GNUC__) || defined(__clang__)
+#  define HPP_TUTORIAL_DEPRECATED __attribute__ ((deprecated))
+#  define HPP_TUTORIAL_DEPRECATED_MESSAGE(message) __attribute__ (( deprecated(#message) ))
+# else
+#  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#   define HPP_TUTORIAL_DEPRECATED __declspec (deprecated)
+#   define HPP_TUTORIAL_DEPRECATED_MESSAGE(message) __declspec ( deprecated(#message) )
+#  else
+// If the compiler is not recognized, drop the feature.
+#   define HPP_TUTORIAL_DEPRECATED /* nothing */
+#   define HPP_TUTORIAL_DEPRECATED_MESSAGE(message)
+#  endif // __MSVC__
+# endif // __cplusplus
+
+# if defined(__GNUC__) || defined(__clang__)
+#  ifndef HPP_TUTORIAL_PRAGMA
+#   define HPP_TUTORIAL_PRAGMA(X) _Pragma(#X)
+#  endif
+#  define HPP_TUTORIAL_DEPRECATED_HEADER(MSG) HPP_TUTORIAL_PRAGMA(GCC warning MSG)
+# elif defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#  define HPP_TUTORIAL_STRINGIZE_(MSG) #MSG
+#  define HPP_TUTORIAL_STRINGIZE(MSG) HPP_TUTORIAL_STRINGIZE_(MSG)
+#  define HPP_TUTORIAL_DEPRECATED_HEADER(MSG) \
+    __pragma(message(__FILE__ "(" HPP_TUTORIAL_STRINGIZE(__LINE__) ") : Warning: " MSG))
+# else
+#  define HPP_TUTORIAL_DEPRECATED_HEADER(MSG)
+# endif
+
+#endif //! HPP_TUTORIAL_DEPRECATED_HH

cmeel.prefix/include/hpp/tutorial/warning.hh

@@ -0,0 +1,35 @@
+/*
+ * This file has been automatically generated by the jrl-cmakemodules.
+ * Please see https://github.com/jrl-umi3218/jrl-cmakemodules/blob/master/warning.hh.cmake for details.
+*/
+
+#ifndef HPP_TUTORIAL_WARNING_HH
+# define HPP_TUTORIAL_WARNING_HH
+
+// Emits a warning in a portable way.
+//
+// To emit a warning, one can insert:
+//
+// #pragma message HPP_TUTORIAL_WARN("your warning message here")
+//
+// The use of this syntax is required as this is /not/ a standardized
+// feature of C++ language or preprocessor, even if most of the
+// compilers support it.
+
+# define HPP_TUTORIAL_WARN_STRINGISE_IMPL(x) #x
+# define HPP_TUTORIAL_WARN_STRINGISE(x) \
+         HPP_TUTORIAL_WARN_STRINGISE_IMPL(x)
+# ifdef __GNUC__
+#   define HPP_TUTORIAL_WARN(exp) ("WARNING: " exp)
+# else
+#  ifdef _MSC_VER
+#   define FILE_LINE_LINK __FILE__ "(" \
+           HPP_TUTORIAL_WARN_STRINGISE(__LINE__) ") : "
+#   define HPP_TUTORIAL_WARN(exp) (FILE_LINE_LINK "WARNING: " exp)
+#  else
+// If the compiler is not recognized, drop the feature.
+#   define HPP_TUTORIAL_WARN(MSG) /* nothing */
+#  endif // __MSVC__
+# endif // __GNUC__
+
+#endif //! HPP_TUTORIAL_WARNING_HH

cmeel.prefix/lib/cmake/hpp_tutorial/cxx-standard.cmake

@@ -0,0 +1,193 @@
+#
+# Copyright (C) 2020 LAAS-CNRS
+#
+# Author: Guilhem Saurel
+#
+
+# .rst: .. ifmode:: internal
+#
+# .. variable:: ENFORCE_MINIMAL_CXX_STANDARD
+#
+# When this is ON, every call to :cmake:command:`CHECK_MINIMAL_CXX_STANDARD`
+# updates the :cmake:variable:`CMAKE_CXX_STANDARD`.
+option(
+  ENFORCE_MINIMAL_CXX_STANDARD
+  "Set CMAKE_CXX_STANDARD if a dependency require it"
+  OFF
+)
+
+# .rst: .. ifmode:: user
+#
+# .. command:: CHECK_MINIMAL_CXX_STANDARD(STANDARD [ENFORCE])
+#
+# Ensure that a minimal C++ standard will be used.
+#
+# This will check the default standard of the current compiler, and set
+# :cmake:variable:`CMAKE_CXX_STANDARD` if necessary, and `ENFORCE` is provided,
+# or :cmake:variable:`ENFORCE_MINIMAL_CXX_STANDARD` is `ON`. Multiple calls to
+# this macro will keep the highest standard.
+#
+# Supported values are 98, 11, 14, 17, and 20.
+#
+macro(CHECK_MINIMAL_CXX_STANDARD STANDARD)
+  set(options ENFORCE)
+  set(oneValueArgs)
+  set(multiValueArgs)
+  cmake_parse_arguments(
+    MINIMAL_CXX_STANDARD
+    "${options}"
+    "${oneValueArgs}"
+    "${multiValueArgs}"
+    ${ARGN}
+  )
+
+  # Get compiler default cxx standard, by printing "__cplusplus" (only once)
+  if(
+    NOT DEFINED _COMPILER_DEFAULT_CXX_STANDARD
+    AND
+      (
+        NOT CMAKE_CROSSCOMPILING
+        OR (CMAKE_CROSSCOMPILING AND CMAKE_CROSSCOMPILING_EMULATOR)
+      )
+  )
+    if(MSVC)
+      # See
+      # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
+      string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus")
+    endif()
+    write_file(
+      ${CMAKE_CURRENT_BINARY_DIR}/cmake/tmp-cxx-standard.cpp
+      "#include <iostream>\nint main(){std::cout << __cplusplus << std::endl;return 0;}"
+    )
+    try_run(
+      _cxx_standard_run_status
+      _cxx_standard_build_status
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_BINARY_DIR}/cmake/tmp-cxx-standard.cpp
+      RUN_OUTPUT_VARIABLE _COMPILER_DEFAULT_CXX_STANDARD
+    )
+    if(
+      _cxx_standard_run_status EQUAL FAILED_TO_RUN
+      OR NOT _cxx_standard_build_status
+    )
+      message(
+        WARNING
+        "Impossible to build or run the script to retrive the _COMPILER_DEFAULT_CXX_STANDARD quantity from current compiler. Setting _COMPILER_DEFAULT_CXX_STANDARD to 199711"
+      )
+      set(_COMPILER_DEFAULT_CXX_STANDARD "199711")
+    endif()
+    string(
+      STRIP "${_COMPILER_DEFAULT_CXX_STANDARD}"
+      _COMPILER_DEFAULT_CXX_STANDARD
+    )
+    message(STATUS "Default C++ standard: ${_COMPILER_DEFAULT_CXX_STANDARD}")
+  endif()
+
+  # Check if we need to upgrade the current minimum
+  if(
+    NOT DEFINED _MINIMAL_CXX_STANDARD
+    OR
+      (
+        NOT ${STANDARD} EQUAL "98"
+        AND
+          (
+            _MINIMAL_CXX_STANDARD EQUAL "98"
+            OR _MINIMAL_CXX_STANDARD LESS ${STANDARD}
+          )
+      )
+  )
+    set(_MINIMAL_CXX_STANDARD "${STANDARD}" CACHE INTERNAL "")
+    message(STATUS "Minimal C++ standard upgraded to ${_MINIMAL_CXX_STANDARD}")
+  endif()
+
+  # Check if a non-trivial minimum has been requested
+  if(DEFINED _MINIMAL_CXX_STANDARD AND NOT _MINIMAL_CXX_STANDARD EQUAL 98)
+    if(DEFINED CMAKE_CXX_STANDARD)
+      set(_CURRENT_STANDARD ${CMAKE_CXX_STANDARD})
+    elseif(DEFINED _COMPILER_DEFAULT_CXX_STANDARD)
+      # ref
+      # https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+      # for constants
+      if(_COMPILER_DEFAULT_CXX_STANDARD EQUAL 199711)
+        set(_CURRENT_STANDARD 98)
+      elseif(_COMPILER_DEFAULT_CXX_STANDARD EQUAL 201103)
+        set(_CURRENT_STANDARD 11)
+      elseif(_COMPILER_DEFAULT_CXX_STANDARD EQUAL 201402)
+        set(_CURRENT_STANDARD 14)
+      elseif(_COMPILER_DEFAULT_CXX_STANDARD EQUAL 201703)
+        set(_CURRENT_STANDARD 17)
+        # C++20: g++-9 defines c++2a with literal 201709, g++-11 & clang-10
+        # define c++2a with literal 202002
+      elseif(
+        _COMPILER_DEFAULT_CXX_STANDARD EQUAL 201709
+        OR _COMPILER_DEFAULT_CXX_STANDARD EQUAL 202002
+      )
+        set(_CURRENT_STANDARD 20)
+      else()
+        message(
+          FATAL_ERROR
+          "Unknown current C++ standard ${_COMPILER_DEFAULT_CXX_STANDARD} while trying to check for >= ${_MINIMAL_CXX_STANDARD}"
+        )
+      endif()
+    else()
+      set(_CURRENT_STANDARD 98)
+    endif()
+
+    # Check that the requested minimum is higher than the currently selected
+    if(
+      _CURRENT_STANDARD EQUAL 98
+      OR _CURRENT_STANDARD LESS _MINIMAL_CXX_STANDARD
+    )
+      message(
+        STATUS
+        "Incompatible C++ standard detected: upgrade required from ${_CURRENT_STANDARD} to >= ${_MINIMAL_CXX_STANDARD}"
+      )
+      # Check that the requested minimum is higher than any pre-existing
+      # CMAKE_CXX_STANDARD
+      if(
+        NOT CMAKE_CXX_STANDARD
+        OR CMAKE_CXX_STANDARD EQUAL 98
+        OR CMAKE_CXX_STANDARD LESS _MINIMAL_CXX_STANDARD
+      )
+        # Throw error if a specific version is required and the currently
+        # desired one is incompatible
+        if(CMAKE_CXX_STANDARD_REQUIRED)
+          message(
+            FATAL_ERROR
+            "CMAKE_CXX_STANDARD_REQUIRED set - cannot upgrade incompatible standard"
+          )
+        endif()
+        # Enforcing a standard version is required - check if we can upgrade
+        # automatically
+        if(ENFORCE_MINIMAL_CXX_STANDARD OR MINIMAL_CXX_STANDARD_ENFORCE)
+          set(CMAKE_CXX_STANDARD ${_MINIMAL_CXX_STANDARD})
+          message(
+            STATUS
+            "CMAKE_CXX_STANDARD automatically upgraded from ${_CURRENT_STANDARD} to ${CMAKE_CXX_STANDARD}"
+          )
+        else()
+          message(
+            FATAL_ERROR
+            "CMAKE_CXX_STANDARD upgrade from ${_CURRENT_STANDARD} to >= ${_MINIMAL_CXX_STANDARD} required"
+          )
+        endif()
+      endif()
+    else() # requested minimum is higher than the currently selected
+      message(
+        STATUS
+        "C++ standard sufficient: Minimal required ${_MINIMAL_CXX_STANDARD}, currently defined: ${_CURRENT_STANDARD}"
+      )
+      # current C++ standard was not set in CMake but we enforce it
+      if(
+        NOT DEFINED CMAKE_CXX_STANDARD
+        AND (ENFORCE_MINIMAL_CXX_STANDARD OR MINIMAL_CXX_STANDARD_ENFORCE)
+      )
+        message(
+          STATUS
+          "CMAKE_CXX_STANDARD was not set: automatically set to currently defined standard ${_CURRENT_STANDARD}"
+        )
+        set(CMAKE_CXX_STANDARD ${_CURRENT_STANDARD})
+      endif()
+    endif() # requested minimum is higher than the currently selected
+  endif()
+endmacro()

cmeel.prefix/lib/cmake/hpp_tutorial/hpp_tutorialConfig.cmake

@@ -0,0 +1,209 @@
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was Config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+macro(check_required_components _NAME)
+  foreach(comp ${${_NAME}_FIND_COMPONENTS})
+    if(NOT ${_NAME}_${comp}_FOUND)
+      if(${_NAME}_FIND_REQUIRED_${comp})
+        set(${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+
+####################################################################################
+
+
+
+set(skip_this_file TRUE)
+if(NOT hpp_tutorial_FOUND)
+  set(skip_this_file FALSE)
+endif()
+if(skip_this_file)
+  foreach(component ${hpp_tutorial_FIND_COMPONENTS})
+    if(NOT "hpp_tutorial_${component}_FOUND")
+      set(skip_this_file FALSE)
+    endif()
+  endforeach()
+endif()
+if(skip_this_file)
+  return()
+endif()
+
+set("hpp_tutorial_INCLUDE_DIRS" "${PACKAGE_PREFIX_DIR}/include")
+set("HPP_TUTORIAL_INCLUDE_DIRS" "${PACKAGE_PREFIX_DIR}/include")
+set("hpp_tutorial_DOXYGENDOCDIR" "${PACKAGE_PREFIX_DIR}/share/doc/hpp_tutorial/doxygen-html")
+set(
+  "HPP_TUTORIAL_DOXYGENDOCDIR"
+  "${PACKAGE_PREFIX_DIR}/share/doc/hpp_tutorial/doxygen-html"
+)
+set("hpp_tutorial_DEPENDENCIES" "hpp-manipulation;example-robot-data;hpp-gepetto-viewer")
+set("hpp_tutorial_PKG_CONFIG_DEPENDENCIES" "")
+
+set(
+  CMAKE_MODULE_PATH
+  ${CMAKE_MODULE_PATH}
+  
+)
+
+# Find absolute library paths for all _PKG_CONFIG_LIBS as CMake expects full paths, while pkg-config does not.
+set(_PACKAGE_CONFIG_LIBRARIES "")
+set("_hpp_tutorial_PKG_CONFIG_LIBDIR" "${pcfiledir}/../../lib")
+set("_hpp_tutorial_PKG_CONFIG_LIBS_LIST" "")
+if(_hpp_tutorial_PKG_CONFIG_LIBS_LIST)
+  string(FIND ${_hpp_tutorial_PKG_CONFIG_LIBS_LIST} ", " _is_comma_space)
+  while(_is_comma_space GREATER -1)
+    string(
+      REPLACE ", "
+      ","
+      _hpp_tutorial_PKG_CONFIG_LIBS_LIST
+      "${_hpp_tutorial_PKG_CONFIG_LIBS_LIST}"
+    )
+    string(FIND ${_hpp_tutorial_PKG_CONFIG_LIBS_LIST} ", " _is_comma_space)
+  endwhile()
+  string(
+    REPLACE " "
+    ";"
+    _hpp_tutorial_PKG_CONFIG_LIBS_LIST
+    "${_hpp_tutorial_PKG_CONFIG_LIBS_LIST}"
+  )
+  set(LIBDIR_HINTS ${_hpp_tutorial_PKG_CONFIG_LIBDIR})
+  foreach(component ${_hpp_tutorial_PKG_CONFIG_LIBS_LIST})
+    string(STRIP ${component} component)
+    # If the component is a link directory ("-L/full/path"), append to LIBDIR_HINTS.
+    string(FIND ${component} "-L" _is_library_dir)
+    if(${_is_library_dir} EQUAL 0)
+      string(REGEX REPLACE "^-L" "" lib_path ${component})
+      list(APPEND LIBDIR_HINTS "${lib_path}")
+      continue()
+    endif()
+    # If the component is a library name
+    string(FIND ${component} "-l" _is_library_name)
+    if(${_is_library_name} EQUAL 0)
+      string(REGEX REPLACE "^-l" "" lib ${component})
+      find_library(abs_lib_${lib} ${lib} HINTS ${LIBDIR_HINTS})
+      if(NOT abs_lib_${lib})
+        if(_LIBDIR_HINTS)
+          message(STATUS "${lib} searched on ${_LIBDIR_HINTS} not FOUND.")
+        else()
+          message(STATUS "${lib} not FOUND.")
+        endif()
+      else()
+        if(_LIBDIR_HINTS)
+          message(
+            STATUS
+            "${lib} searched on ${_LIBDIR_HINTS} FOUND. ${lib} at ${abs_lib_${lib}}"
+          )
+        else()
+          message(STATUS "${lib} FOUND. ${lib} at ${abs_lib_${lib}}")
+        endif()
+        list(APPEND _PACKAGE_CONFIG_LIBRARIES "${abs_lib_${lib}}")
+      endif()
+      unset(abs_lib_${lib} CACHE)
+      continue()
+    endif()
+    # If the component contains a collection of additional arguments
+    string(FIND ${component} "," _is_collection)
+    if(${_is_collection} GREATER -1)
+      string(REPLACE "," ";" component_list "${component}")
+      list(GET component_list -1 lib_info)
+      set(options ${component})
+      list(REMOVE_AT options -1)
+      string(FIND ${lib_info} "-l" _is_library_name)
+      if(${_is_library_name} GREATER -1)
+        string(REGEX REPLACE "^-l" "" lib ${lib_info})
+        find_library(abs_lib_${lib} ${lib} HINTS ${LIBDIR_HINTS})
+        if(NOT abs_lib_${lib})
+          if(_LIBDIR_HINTS)
+            message(STATUS "${lib} searched on ${_LIBDIR_HINTS} not FOUND.")
+          else()
+            message(STATUS "${lib} not FOUND.")
+          endif()
+        else()
+          if(_LIBDIR_HINTS)
+            message(
+              STATUS
+              "${lib} searched on ${_LIBDIR_HINTS} FOUND. ${lib} at ${abs_lib_${lib}}"
+            )
+          else()
+            message(STATUS "${lib} FOUND. ${lib} at ${abs_lib_${lib}}")
+          endif()
+          list(APPEND _PACKAGE_CONFIG_LIBRARIES "${abs_lib_${lib}}")
+        endif()
+        unset(abs_lib_${lib} CACHE)
+        continue()
+      else() # This is an absolute lib
+        list(APPEND _PACKAGE_CONFIG_LIBRARIES "${component}")
+      endif()
+      continue()
+    endif()
+    # Else, this is just an absolute lib
+    if(EXISTS "${component}")
+      list(APPEND _PACKAGE_CONFIG_LIBRARIES "${component}")
+    endif()
+  endforeach()
+endif(_hpp_tutorial_PKG_CONFIG_LIBS_LIST)
+
+set("hpp_tutorial_LIBRARIES" ${_PACKAGE_CONFIG_LIBRARIES})
+set("HPP_TUTORIAL_LIBRARIES" ${_PACKAGE_CONFIG_LIBRARIES})
+
+
+include("${CMAKE_CURRENT_LIST_DIR}/cxx-standard.cmake")
+
+
+
+include(CMakeFindDependencyMacro)
+if(${CMAKE_VERSION} VERSION_LESS "3.15.0")
+  find_package(hpp-manipulation REQUIRED)
+  find_package(example-robot-data REQUIRED)
+  find_package(hpp-gepetto-viewer REQUIRED)
+else()
+  find_dependency(hpp-manipulation REQUIRED)
+  find_dependency(example-robot-data REQUIRED)
+  find_dependency(hpp-gepetto-viewer REQUIRED)
+endif()
+
+if(COMMAND ADD_REQUIRED_DEPENDENCY)
+  foreach(pkgcfg_dep ${hpp_tutorial_PKG_CONFIG_DEPENDENCIES})
+    # Avoid duplicated lookup.
+    list(FIND $_PKG_CONFIG_REQUIRES "${pkgcfg_dep}" _index)
+    if(${_index} EQUAL -1)
+      ADD_REQUIRED_DEPENDENCY(${pkgcfg_dep})
+    endif()
+  endforeach()
+endif(COMMAND ADD_REQUIRED_DEPENDENCY)
+
+include("${CMAKE_CURRENT_LIST_DIR}/hpp_tutorialTargets.cmake")
+
+foreach(component ${hpp_tutorial_FIND_COMPONENTS})
+  set(comp_file "${CMAKE_CURRENT_LIST_DIR}/${component}Config.cmake")
+  if(EXISTS ${comp_file})
+    include(${comp_file})
+  else()
+    set(hpp_tutorial_${component}_FOUND FALSE)
+  endif()
+  if(hpp_tutorial_${component}_FOUND)
+    message(STATUS "hpp_tutorial: ${component} found.")
+  else()
+    if(hpp_tutorial_FIND_REQUIRED_${component})
+      message(FATAL_ERROR "hpp_tutorial: ${component} not found.")
+    else()
+      message(STATUS "hpp_tutorial: ${component} not found.")
+    endif()
+  endif()
+endforeach()
+check_required_components("hpp_tutorial")
+
+
+CHECK_MINIMAL_CXX_STANDARD(17 ENFORCE)

cmeel.prefix/lib/cmake/hpp_tutorial/hpp_tutorialConfigVersion.cmake

@@ -0,0 +1,65 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major version is the same as the current one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "9.0.0")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("9.0.0" MATCHES "^([0-9]+)\\.")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+    endif()
+  else()
+    set(CVF_VERSION_MAJOR "9.0.0")
+  endif()
+
+  if(PACKAGE_FIND_VERSION_RANGE)
+    # both endpoints of the range must have the expected major version
+    math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1")
+    if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR)
+          OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT)))
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX)))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+  else()
+    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()