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"

// user include files
#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 {
    loadPlugin(findType(pset));
    cache_->validate(pset);
    //all names are good
    auto n =pset.getParameterNames();
    validatedLabels.insert(n.begin(),n.end());
  }
  
  void writeCfi_(std::ostream& os,
                 bool& startWithComma,
                 int indentation,
                 bool& wroteSomething) const final {
    if(not defaultType_.empty()) {
      auto conf = edmplugin::standard::config();
      conf.allowNoCache();
      edmplugin::PluginManager::configure(conf);

      loadPlugin(defaultType_);
      
      cache_->writeCfi(os,startWithComma,indentation);
      wroteSomething = true;
    }
  }
  
  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::stringstream ss;
    ss << dfh.section() << "." << dfh.counter();
    std::string newSection = ss.str();

    printSpaces(os, indentation);
    os << "Section " << newSection
    << " " << Factory::get()->category() << " Plugins description:\n";
    if(!dfh.brief()) os << "\n";

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

    //loop over all possible plugins
    unsigned int pluginCount = 0;
    std::string previousName;
    for(auto const& info: edmplugin::PluginManager::get()->categoryToInfos().find(Factory::get()->category())->second) {

      // We only want to print the first instance of each plugin name
      if (previousName == info.name_) {
        continue;
      }

      std::stringstream ss;
      ss << dfh.section() << "." << dfh.counter();
      std::string newSection = ss.str();
      printSpaces(os, indentation);
      os << "Section " << newSection <<"."<< ++pluginCount
      << " " << info.name_ << " Plugin description:\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 {
    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_) {
      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_);
  }
  
  void loadPlugin(std::string const& iName) const {
    if(not cache_) {
      cache_ = loadDescription(iName);
    }
  }
  
  std::shared_ptr<ParameterSetDescription>
  loadDescription(std::string const& iName) const {
    using CreatedType = PluginDescriptionAdaptorBase<typename T::CreatedType>;
    std::unique_ptr<CreatedType> a(edmplugin::PluginFactory<CreatedType*()>::get()->create(iName));
    
    std::shared_ptr<ParameterSetDescription> desc = std::make_shared<ParameterSetDescription>(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 --------------------------------
  mutable std::shared_ptr<ParameterSetDescription> cache_;
  std::string typeLabel_;
  std::string defaultType_;
  bool typeLabelIsTracked_;
  
};
}

#endif