PluginDescription.h

Go to the documentation of this file.

#ifndef FWCore_ParameterSet_PluginDescription_h
#define FWCore_ParameterSet_PluginDescription_h
// -*- C++ -*-
//
// Package:     FWCore/ParameterSet
// Class  :     PluginDescription
//
//
// Original Author:  Chris Jones
//         Created:  Wed, 19 Sep 2018 19:23:27 GMT
//

// system include files
#include "FWCore/ParameterSet/interface/ParameterDescriptionNode.h"
#include "FWCore/ParameterSet/interface/PluginDescriptionAdaptorBase.h"
#include "FWCore/PluginManager/interface/PluginFactory.h"
#include "FWCore/PluginManager/interface/PluginManager.h"
#include "FWCore/PluginManager/interface/standard.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"

// user include files
#include <ostream>
#include <sstream>
#include <string>

// forward declarations
namespace edm {
  template <typename T>
  class PluginDescription : public ParameterDescriptionNode {
  public:
    PluginDescription(std::string typeLabel, bool typeLabelIsTracked)
        : typeLabel_{std::move(typeLabel)}, typeLabelIsTracked_{typeLabelIsTracked} {}

    PluginDescription(std::string typeLabel, std::string defaultType, bool typeLabelIsTracked)
        : typeLabel_{std::move(typeLabel)},
          defaultType_{std::move(defaultType)},
          typeLabelIsTracked_{typeLabelIsTracked} {}

    // ---------- const member functions ---------------------
    ParameterDescriptionNode* clone() const final { return new PluginDescription<T>(*this); }

  protected:
    void checkAndGetLabelsAndTypes_(std::set<std::string>& usedLabels,
                                    std::set<ParameterTypes>& parameterTypes,
                                    std::set<ParameterTypes>& wildcardTypes) const final {}

    void validate_(ParameterSet& pset, std::set<std::string>& validatedLabels, bool optional) const final {
      loadDescription(findType(pset)).validate(pset);
      //all names are good
      auto n = pset.getParameterNames();
      validatedLabels.insert(n.begin(), n.end());
    }

    void writeCfi_(std::ostream& os,
                   bool optional,
                   bool& startWithComma,
                   int indentation,
                   CfiOptions& options,
                   bool& wroteSomething) const final {
      if (not defaultType_.empty()) {
        if (!edmplugin::PluginManager::isAvailable()) {
          auto conf = edmplugin::standard::config();
          conf.allowNoCache();
          edmplugin::PluginManager::configure(conf);
        }
        //given each plugin can have very different parameters we should do a full dump
        CfiOptions ops = cfi::Typed{};
        loadDescription(defaultType_).writeCfi(os, startWithComma, indentation, ops);
        wroteSomething = true;
      }
      if (std::holds_alternative<cfi::ClassFile>(options)) {
        std::get<cfi::ClassFile>(options).parameterMustBeTyped();
      }
    }

    bool hasNestedContent_() const final { return true; }

    void printNestedContent_(std::ostream& os, bool /*optional*/, DocFormatHelper& dfh) const final {
      int indentation = dfh.indentation();

      using CreatedType = PluginDescriptionAdaptorBase<typename T::CreatedType>;
      using Factory = edmplugin::PluginFactory<CreatedType*()>;

      std::string const& pluginCategory = Factory::get()->category();

      printSpaces(os, indentation);
      os << "There are multiple possible different descriptions for this ParameterSet\n";
      printSpaces(os, indentation);
      os << "because it will be used by a helper plugin object contained inside the top level\n";
      printSpaces(os, indentation);
      os << "module plugin object and the type of the helper plugin object is configurable.\n";
      printSpaces(os, indentation);
      os << "Or if it is in a vector of ParameterSets it might be used by multiple\n";
      printSpaces(os, indentation);
      os << "helper plugin objects and each could be configured with a different plugin type.\n";
      printSpaces(os, indentation);
      os << "Each plugin type could allow a different set of configuration parameters.\n";
      printSpaces(os, indentation);
      os << "Each subsection of this section has one of the possible descriptions.\n";
      printSpaces(os, indentation);
      os << "All of these plugins are from the category \"" << pluginCategory << "\".\n";
      printSpaces(os, indentation);
      os << "The plugin type is specified by the parameter named \"" << typeLabel_ << "\".\n";

      if (!dfh.brief()) {
        os << "\n";
      }
      std::string section = dfh.sectionOfCategoryAlreadyPrinted(pluginCategory);
      if (!section.empty()) {
        printSpaces(os, indentation);
        os << "*** The descriptions for this plugin category already started printing above (see Section " << section
           << ")! ***\n";
        printSpaces(os, indentation);
        os << "*** We might still be in the middle of that printout at this point because it might be recursive. ***\n";
        printSpaces(os, indentation);
        os << "*** We'll not duplicate that printout and skip it. ***\n";
        printSpaces(os, indentation);
        os << "*** (N.B. If we tried to print it again, we might fall into an infinite recursion.) ***\n";

        if (!dfh.brief()) {
          os << "\n";
        }
        return;
      }
      dfh.addCategory(pluginCategory, dfh.section());

      indentation -= DocFormatHelper::offsetSectionContent();

      //loop over all possible plugins
      unsigned int pluginCount = 1;
      std::string previousName;
      for (auto const& info : edmplugin::PluginManager::get()->categoryToInfos().find(pluginCategory)->second) {
        // We only want to print the first instance of each plugin name
        if (previousName == info.name_) {
          continue;
        }

        std::stringstream ss;
        ss << dfh.section() << "." << pluginCount;
        ++pluginCount;
        std::string newSection = ss.str();
        printSpaces(os, indentation);
        os << "Section " << newSection << " ParameterSet description for plugin named \"" << info.name_ << "\"\n";
        if (!dfh.brief())
          os << "\n";

        DocFormatHelper new_dfh(dfh);
        new_dfh.init();
        new_dfh.setSection(newSection);

        loadDescription(info.name_).print(os, new_dfh);

        previousName = info.name_;
      }
    }

    bool exists_(ParameterSet const& pset) const final {
      CMS_SA_ALLOW return pset.existsAs<std::string>(typeLabel_, typeLabelIsTracked_);
    }

    bool partiallyExists_(ParameterSet const& pset) const final { return exists_(pset); }

    int howManyXORSubNodesExist_(ParameterSet const& pset) const final { return exists(pset) ? 1 : 0; }

  private:
    std::string findType(edm::ParameterSet const& iPSet) const {
      if (typeLabelIsTracked_) {
        CMS_SA_ALLOW if (iPSet.existsAs<std::string>(typeLabel_) || defaultType_.empty()) {
          return iPSet.getParameter<std::string>(typeLabel_);
        }
        else {
          return defaultType_;
        }
      }
      if (defaultType_.empty()) {
        return iPSet.getUntrackedParameter<std::string>(typeLabel_);
      }
      return iPSet.getUntrackedParameter<std::string>(typeLabel_, defaultType_);
    }

    ParameterSetDescription loadDescription(std::string const& iName) const {
      using CreatedType = PluginDescriptionAdaptorBase<typename T::CreatedType>;
      std::unique_ptr<CreatedType> a(edmplugin::PluginFactory<CreatedType*()>::get()->create(iName));

      ParameterSetDescription desc = a->description();

      //There is no way to check to see if a node already wants a label
      if (typeLabelIsTracked_) {
        if (defaultType_.empty()) {
          desc.add<std::string>(typeLabel_);
        } else {
          desc.add<std::string>(typeLabel_, defaultType_);
        }
      } else {
        if (defaultType_.empty()) {
          desc.addUntracked<std::string>(typeLabel_);
        } else {
          desc.addUntracked<std::string>(typeLabel_, defaultType_);
        }
      }
      return desc;
    }

    // ---------- member data --------------------------------
    std::string typeLabel_;
    std::string defaultType_;
    bool typeLabelIsTracked_;
  };
}  // namespace edm

#endif