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 <boost/serialization/access.hpp>
#include <functional>
#include <memory>
TESSERACT_COMMON_IGNORE_WARNINGS_POP
 
namespace tesseract_common
{
// Forward declare
class Resource;
 
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;
  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();
  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;
 
private:
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
 
  std::unordered_map<std::string, std::string> package_paths_;
};
 
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;
  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;
  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;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
}  // namespace tesseract_common
 
#include <boost/serialization/export.hpp>
#include <boost/serialization/tracking.hpp>
BOOST_CLASS_EXPORT_KEY2(tesseract_common::GeneralResourceLocator, "GeneralResourceLocator")
BOOST_CLASS_EXPORT_KEY2(tesseract_common::SimpleLocatedResource, "SimpleLocatedResource")
BOOST_CLASS_EXPORT_KEY2(tesseract_common::BytesResource, "BytesResource")
 
#endif  // TESSERACT_COMMON_RESOURCE_LOCATOR_H