resource.hpp

// Copyright 2024 Robin Müller
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <map>
#include <set>
#include <string>
#include <type_traits>
#include <vector>
 
#include "auto_apms_util/container.hpp"
#include "auto_apms_util/exceptions.hpp"
#include "auto_apms_util/string.hpp"
#include "pluginlib/class_loader.hpp"
 
namespace auto_apms_util
{


std::set<std::string> getPackagesWithResourceType(
  const std::string & resource_type, const std::set<std::string> & exclude_packages = {});

std::set<std::string> getPackagesWithPluginResources(const std::set<std::string> & exclude_packages = {});

std::string getPluginXMLPath(const std::string & package);

std::vector<std::string> collectPluginXMLPaths(const std::set<std::string> & exclude_packages = {});

 
// clang-format off
// clang-format on
template <typename BaseT>
class PluginClassLoader : public pluginlib::ClassLoader<BaseT>
{
public:
  PluginClassLoader(
    const std::string & base_package, const std::string & base_class,
    const std::set<std::string> & exclude_packages = {});

  static PluginClassLoader makeUnambiguousPluginClassLoader(
    const std::string & base_package, const std::string & base_class,
    const std::set<std::string> & exclude_packages = {},
    const std::map<std::string, std::string> & reserved_names = {});

  static void verifyUnambiguousClassNames(
    const std::string & base_package, const std::string & base_class,
    const std::set<std::string> & exclude_packages = {},
    const std::map<std::string, std::string> & reserved_names = {});

  std::map<std::string, std::string> getClassPackageMap();
};
 
// #####################################################################################################################
// ################################              DEFINITIONS              ##############################################
// #####################################################################################################################
 
template <typename BaseT>
inline PluginClassLoader<BaseT>::PluginClassLoader(
  const std::string & base_package, const std::string & base_class, const std::set<std::string> & exclude_packages)
: pluginlib::ClassLoader<BaseT>(base_package, base_class, "", collectPluginXMLPaths(exclude_packages))
{
}
 
template <typename BaseT>
inline PluginClassLoader<BaseT> PluginClassLoader<BaseT>::makeUnambiguousPluginClassLoader(
  const std::string & base_package, const std::string & base_class, const std::set<std::string> & exclude_packages,
  const std::map<std::string, std::string> & reserved_names)
{
  verifyUnambiguousClassNames(base_package, base_class, exclude_packages, reserved_names);
  return {base_package, base_class, exclude_packages};
}
 
template <typename BaseT>
inline void PluginClassLoader<BaseT>::verifyUnambiguousClassNames(
  const std::string & base_package, const std::string & base_class, const std::set<std::string> & exclude_packages,
  const std::map<std::string, std::string> & reserved_names)
{
  std::map<std::string, std::vector<std::string>> packages_for_class_name;
  const std::set<std::string> packages = getPackagesWithPluginResources(exclude_packages);
  for (const auto & package : packages) {
    auto single_package_loader =
      pluginlib::ClassLoader<BaseT>(base_package, base_class, "", {getPluginXMLPath(package)});
    for (const auto & class_name : single_package_loader.getDeclaredClasses()) {
      packages_for_class_name[class_name].push_back(package);
    }
  }
 
  // Reserved class names are considered as registered
  for (const auto & [class_name, package] : reserved_names) {
    packages_for_class_name[class_name].push_back(package);
  }
 
  // Determine if there are duplicate class names
  std::vector<std::string> error_details;
  for (const auto & [class_name, packages] : packages_for_class_name) {
    if (packages.size() > 1) {
      error_details.push_back(
        "- Class '" + class_name + "' found in packages ['" + auto_apms_util::join(packages, "', '") + "'].");
    }
  }
  if (!error_details.empty()) {
    throw exceptions::ResourceError(
      "Ambiguous class names found! PluginClassLoader (Base: " + base_class +
      ") verified with verifyUnambiguousClassNames() won't register resources from packages "
      "that use already existing lookup names. Found the following duplicates:\n" +
      auto_apms_util::join(error_details, "\n"));
  }
}
 
template <typename BaseT>
inline std::map<std::string, std::string> PluginClassLoader<BaseT>::getClassPackageMap()
{
  std::map<std::string, std::string> map;
  for (const std::string & class_name : this->getDeclaredClasses()) {
    map[class_name] = this->getClassPackage(class_name);
  }
  return map;
}
 
}  // namespace auto_apms_util