ros_uri.hpp

Go to the documentation of this file.

#ifndef ROS_URI_HPP_
#define ROS_URI_HPP_

#include <vector>
#include <string>
#include <ros/ros.h>
#include <ros/package.h>
#include "ros_uri/filesystem_ext.hpp"

namespace fs = boost::filesystem;

class ros_uri {
private:
        inline static const std::string getPackagePrefix() {
                return "package://";
        };

        inline static const std::string getFilePrefix() {
                return "file://";
        };
public:
        static std::string absolute_path(std::string uriString) {
                if (uriString.find(getPackagePrefix()) == 0) {
                        std::size_t pos = uriString.find("/", getPackagePrefix().size());
                        std::string packageName = uriString.substr(getPackagePrefix().size(), pos - getPackagePrefix().size());
                        std::string packagePathStr = ros::package::getPath(packageName);
                        return packagePathStr + uriString.substr(pos, uriString.size() - pos);
                } else if (uriString.find(getFilePrefix()) == 0) {
                        std::string pathStr = uriString.substr(getFilePrefix().size(), uriString.size() - getFilePrefix().size());
                        return pathStr;
                }
                return "";
        };

        static std::string package_uri(std::string pathStr, std::string packageName = std::string()) {
                // Get the abs path
                fs::path absPath = fs::path(pathStr);

                // if there is no package name given, start searching.
                if (packageName == std::string()) {
                        // get all possible packaged
                        std::vector<std::string> packageVector;
                        ros::package::getAll(packageVector);

                        // do a stable sort, so we can do the binary search
                        std::stable_sort(packageVector.begin(), packageVector.end());

                        // start with the current path and then get step by step up the path
                        fs::path parentPath = absPath;

                        // as long as there is a parent do the search process.
                        while (parentPath != fs::path()) {
                                // get the name of the file
                                fs::path filename = parentPath.filename();

                                // do the binary search for the package, if it's found
                                if (std::binary_search(packageVector.begin(), packageVector.end(), filename)) {
                                        // get the path to package, and if it equal to the rest of the path nothing to do anymore
                                        fs::path possiblePath = fs::path(ros::package::getPath(filename.string()));
                                        if (possiblePath == parentPath.string()) {
                                                packageName = filename.string();
                                                // stop looping
                                                break;
                                        }
                                }

                                parentPath = parentPath.parent_path();
                        }
                }

                // create the uri
                fs::path baseFolder = ros::package::getPath(packageName);
                fs::path relativePath = fs::pathext::relative_path(absPath, baseFolder);
                return getPackagePrefix() + packageName + "/" + relativePath.string();
        };

        static std::string file_uri(fs::path path) {
                return getFilePrefix() + fs::absolute(path).string();
        };
};


#endif /* ROS_URI_HPP_ */