Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	include/pinocchio/parsers/utils.hpp	Lines:	19	24	79.2 %
Date:	2024-01-23 21:41:47	Branches:	25	60	41.7 %


//
// Copyright (c) 2015 - 2016 CNRS
//

#ifndef __pinocchio_parsers_utils_hpp__
#define __pinocchio_parsers_utils_hpp__

#include <iostream>
#include <limits>
#include <sstream>
// #include <stdexcept>

#include <boost/filesystem/fstream.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>

#include "pinocchio/utils/file-explorer.hpp"
#include <boost/filesystem.hpp>

#include <exception>

namespace pinocchio
{
  ///
  /// \brief Supported model file extensions
  ///
  enum ModelFileExtensionType{
    UNKNOWN = 0,
    URDF
  };

  ///
  /// \brief Extract the type of the given model file according to its extension
  ///
  /// \param[in] filename The complete path to the model file.
  ///
  /// \return The type of the extension of the model file
  ///
  inline ModelFileExtensionType checkModelFileExtension(const std::string & filename)
  {
    const std::string extension = filename.substr(filename.find_last_of(".") + 1);

    if (extension == "urdf")
      return URDF;

    return UNKNOWN;
  }



  /**
   * @brief      Retrieve the path of the file whose path is given in URL-format.
   *             Currently convert from the following patterns : package:// or file://
   *
   * @param[in]  string          The path given in the url-format
   * @param[in]  package_dirs    A list of packages directories where to search for files
   *                             if its pattern starts with package://
   *
   * @return     The path to the file (can be a relative or absolute path)
   */
   inline std::string retrieveResourcePath(const std::string & string,
                                           const std::vector<std::string> & package_dirs)
   {

    namespace bf = boost::filesystem;
    std::string result_path;

    const std::string separator("://");
    const std::size_t pos_separator = string.find(separator);
    bf::path string_path(string);

    if (pos_separator != std::string::npos)
    {
      std::string scheme = string.substr(0, pos_separator);
      std::string path = string.substr(pos_separator+3, std::string::npos);

      if(scheme == "package")
      {
        // if exists p1/string, path = p1/string,
        // else if exists p2/string, path = p2/string
        // else return an empty string that may provoke an error in loadPolyhedronFromResource()

        // concatenate package_path with filename
        for (std::size_t i = 0; i < package_dirs.size(); ++i)
        {
          if ( bf::exists( bf::path(package_dirs[i] + "/" + path)))
          {
            result_path = std::string( package_dirs[i] + "/" + path );
            break;
          }
        }
      }
      else if (scheme == "file")
      {
        result_path = path;
      }
      else
      {
        const std::string exception_message ("Schemes of form" + scheme + "are not handled");
        throw std::invalid_argument(exception_message);
      }
    }
    else if (string_path.is_relative())
    {
      // handle the case where a relative mesh path is specified without using //package
      for (std::size_t i = 0; i < package_dirs.size(); ++i)
        {
          if ( bf::exists( bf::path(package_dirs[i] + "/" + string)))
          {
            result_path = std::string( package_dirs[i] + "/" + string);
            break;
          }
        }
    }
    else // return the entry string
    {
      result_path = string;
    }

    return result_path;
   }

} // namespace pinocchio

#endif // __pinocchio_parsers_utils_hpp__


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			//
2			// Copyright (c) 2015 - 2016 CNRS
3			//
4
5			#ifndef __pinocchio_parsers_utils_hpp__
6			#define __pinocchio_parsers_utils_hpp__
7
8			#include <iostream>
9			#include <limits>
10			#include <sstream>
11			// #include <stdexcept>
12
13			#include <boost/filesystem/fstream.hpp>
14			#include <boost/foreach.hpp>
15			#include <boost/format.hpp>
16
17			#include "pinocchio/utils/file-explorer.hpp"
18			#include <boost/filesystem.hpp>
19
20			#include <exception>
21
22			namespace pinocchio
23			{
24			///
25			/// \brief Supported model file extensions
26			///
27			enum ModelFileExtensionType{
28			UNKNOWN = 0,
29			URDF
30			};
31
32			///
33			/// \brief Extract the type of the given model file according to its extension
34			///
35			/// \param[in] filename The complete path to the model file.
36			///
37			/// \return The type of the extension of the model file
38			///
39			inline ModelFileExtensionType checkModelFileExtension(const std::string & filename)
40			{
41			const std::string extension = filename.substr(filename.find_last_of(".") + 1);
42
43			if (extension == "urdf")
44			return URDF;
45
46			return UNKNOWN;
47			}
48
49
50
51			/**
52			* @brief Retrieve the path of the file whose path is given in URL-format.
53			* Currently convert from the following patterns : package:// or file://
54			*
55			* @param[in] string The path given in the url-format
56			* @param[in] package_dirs A list of packages directories where to search for files
57			* if its pattern starts with package://
58			*
59			* @return The path to the file (can be a relative or absolute path)
60			*/
61		730	inline std::string retrieveResourcePath(const std::string & string,
62			const std::vector<std::string> & package_dirs)
63			{
64
65			namespace bf = boost::filesystem;
66		730	std::string result_path;
67
68	✓✗	1460	const std::string separator("://");
69		730	const std::size_t pos_separator = string.find(separator);
70	✓✗	1460	bf::path string_path(string);
71
72	✓✓	730	if (pos_separator != std::string::npos)
73			{
74	✓✗	1458	std::string scheme = string.substr(0, pos_separator);
75	✓✗	1458	std::string path = string.substr(pos_separator+3, std::string::npos);
76
77	✓✗	729	if(scheme == "package")
78			{
79			// if exists p1/string, path = p1/string,
80			// else if exists p2/string, path = p2/string
81			// else return an empty string that may provoke an error in loadPolyhedronFromResource()
82
83			// concatenate package_path with filename
84	✓✗	729	for (std::size_t i = 0; i < package_dirs.size(); ++i)
85			{
86	✓✗✓✗ ✓✗✓✗ ✓✗	729	if ( bf::exists( bf::path(package_dirs[i] + "/" + path)))
87			{
88	✓✗✓✗	729	result_path = std::string( package_dirs[i] + "/" + path );
89		729	break;
90			}
91			}
92			}
93			else if (scheme == "file")
94			{
95			result_path = path;
96			}
97			else
98			{
99			const std::string exception_message ("Schemes of form" + scheme + "are not handled");
100			throw std::invalid_argument(exception_message);
101			}
102			}
103	✓✗✓✗	1	else if (string_path.is_relative())
104			{
105			// handle the case where a relative mesh path is specified without using //package
106	✓✗	1	for (std::size_t i = 0; i < package_dirs.size(); ++i)
107			{
108	✓✗✓✗ ✓✗✓✗ ✓✗	1	if ( bf::exists( bf::path(package_dirs[i] + "/" + string)))
109			{
110	✓✗✓✗	1	result_path = std::string( package_dirs[i] + "/" + string);
111		1	break;
112			}
113			}
114			}
115			else // return the entry string
116			{
117			result_path = string;
118			}
119
120		1460	return result_path;
121			}
122
123			} // namespace pinocchio
124
125			#endif // __pinocchio_parsers_utils_hpp__