resource_locator.h

Go to the documentation of this file.

 
#ifndef TESSERACT_COMMON_RESOURCE_LOCATOR_H
#define TESSERACT_COMMON_RESOURCE_LOCATOR_H
 
#include <tesseract_common/macros.h>
TESSERACT_COMMON_IGNORE_WARNINGS_PUSH
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <boost/serialization/export.hpp>
TESSERACT_COMMON_IGNORE_WARNINGS_POP
 
#include <filesystem>
 
namespace boost::serialization
{
class access;
}
 
namespace tesseract_common
{
// Forward declare
class Resource;
struct Serialization;
 
class ResourceLocator
{
public:
  using Ptr = std::shared_ptr<ResourceLocator>;
  using ConstPtr = std::shared_ptr<const ResourceLocator>;
 
  virtual ~ResourceLocator() = default;
 
  virtual std::shared_ptr<Resource> locateResource(const std::string& url) const = 0;
 
  bool operator==(const ResourceLocator& rhs) const;
  bool operator!=(const ResourceLocator& rhs) const;
 
private:
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
class GeneralResourceLocator : public ResourceLocator
{
public:
  using Ptr = std::shared_ptr<GeneralResourceLocator>;
  using ConstPtr = std::shared_ptr<const GeneralResourceLocator>;
  GeneralResourceLocator(const std::vector<std::string>& environment_variables = { "TESSERACT_RESOURCE_PATH",
                                                                                   "ROS_PACKAGE_PATH" });
  GeneralResourceLocator(const std::vector<std::filesystem::path>& paths,
                         const std::vector<std::string>& environment_variables = { "TESSERACT_RESOURCE_PATH",
                                                                                   "ROS_PACKAGE_PATH" });
  GeneralResourceLocator(const GeneralResourceLocator&) = default;
  GeneralResourceLocator& operator=(const GeneralResourceLocator&) = default;
  GeneralResourceLocator(GeneralResourceLocator&&) = default;
  GeneralResourceLocator& operator=(GeneralResourceLocator&&) = default;
  ~GeneralResourceLocator() override = default;
 
  std::shared_ptr<Resource> locateResource(const std::string& url) const override;
 
  bool operator==(const GeneralResourceLocator& rhs) const;
  bool operator!=(const GeneralResourceLocator& rhs) const;
 
  bool addPath(const std::filesystem::path& path);
 
  bool loadEnvironmentVariable(const std::string& environment_variable);
 
private:
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
 
  std::unordered_map<std::string, std::string> package_paths_;
 
  void processToken(const std::string& token);
};
 
class Resource : public ResourceLocator
{
public:
  using Ptr = std::shared_ptr<Resource>;
  using ConstPtr = std::shared_ptr<const Resource>;
 
  virtual bool isFile() const = 0;
 
  virtual std::string getUrl() const = 0;
 
  virtual std::string getFilePath() const = 0;
 
  virtual std::vector<uint8_t> getResourceContents() const = 0;
 
  virtual std::shared_ptr<std::istream> getResourceContentStream() const = 0;
 
  bool operator==(const Resource& rhs) const;
  bool operator!=(const Resource& rhs) const;
 
private:
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
using SimpleResourceLocatorFn = std::function<std::string(const std::string&)>;
 
class SimpleLocatedResource : public Resource
{
public:
  using Ptr = std::shared_ptr<SimpleLocatedResource>;
  using ConstPtr = std::shared_ptr<const SimpleLocatedResource>;
 
  SimpleLocatedResource() = default;
 
  SimpleLocatedResource(std::string url, std::string filename, ResourceLocator::ConstPtr parent = nullptr);
  ~SimpleLocatedResource() override = default;
  SimpleLocatedResource(const SimpleLocatedResource&) = default;
  SimpleLocatedResource& operator=(const SimpleLocatedResource&) = default;
  SimpleLocatedResource(SimpleLocatedResource&&) = default;
  SimpleLocatedResource& operator=(SimpleLocatedResource&&) = default;
 
  bool isFile() const override final;
 
  std::string getUrl() const override final;
 
  std::string getFilePath() const override final;
 
  std::vector<uint8_t> getResourceContents() const override final;
 
  std::shared_ptr<std::istream> getResourceContentStream() const override final;
 
  Resource::Ptr locateResource(const std::string& url) const override final;
 
  bool operator==(const SimpleLocatedResource& rhs) const;
  bool operator!=(const SimpleLocatedResource& rhs) const;
 
private:
  std::string url_;
  std::string filename_;
  ResourceLocator::ConstPtr parent_;
 
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
class BytesResource : public tesseract_common::Resource
{
public:
  BytesResource() = default;
 
  BytesResource(std::string url, std::vector<uint8_t> bytes, ResourceLocator::ConstPtr parent = nullptr);
  BytesResource(std::string url, const uint8_t* bytes, size_t bytes_len, ResourceLocator::ConstPtr parent = nullptr);
  ~BytesResource() override = default;
  BytesResource(const BytesResource&) = default;
  BytesResource& operator=(const BytesResource&) = default;
  BytesResource(BytesResource&&) = default;
  BytesResource& operator=(BytesResource&&) = default;
 
  bool isFile() const override final;
  std::string getUrl() const override final;
  std::string getFilePath() const override final;
  std::vector<uint8_t> getResourceContents() const override final;
  std::shared_ptr<std::istream> getResourceContentStream() const override final;
  Resource::Ptr locateResource(const std::string& url) const override final;
 
  bool operator==(const BytesResource& rhs) const;
  bool operator!=(const BytesResource& rhs) const;
 
private:
  std::string url_;
  std::vector<uint8_t> bytes_;
  ResourceLocator::ConstPtr parent_;
 
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
}  // namespace tesseract_common
BOOST_SERIALIZATION_ASSUME_ABSTRACT(tesseract_common::ResourceLocator)
BOOST_SERIALIZATION_ASSUME_ABSTRACT(tesseract_common::Resource)
 
BOOST_CLASS_EXPORT_KEY(tesseract_common::GeneralResourceLocator)
BOOST_CLASS_EXPORT_KEY(tesseract_common::SimpleLocatedResource)
BOOST_CLASS_EXPORT_KEY(tesseract_common::BytesResource)
 
#endif  // TESSERACT_COMMON_RESOURCE_LOCATOR_H