ParameterDescriptionCases.h

Go to the documentation of this file.

#ifndef FWCore_ParameterSet_ParameterDescriptionCases_h
#define FWCore_ParameterSet_ParameterDescriptionCases_h

// This class is used to store temporary objects created when
// building ParameterSwitch's in a ParameterSetDescription.
// It gets created while evaluating an expression something
// like
//
// parameterSetDescription.ifValue( ParameterDescription<int>("switch", 0),
//                                  0 >> ParameterDescription<int>("label1", 11) or
//                                  1 >> ParameterDescription<float>("label2", 11.0f) or
//                                  2 >> ParameterDescription<std::string>("label3", "aValue");
// It hold the temporary results of the operator>> and operator||
// functions in the expression.  The ONLY way to create one
// is via the operator>> function. The intent is that user
// should not need to save this temporary result nor directly
// reference this class, but ...

// If one decided to save the value then one should be aware
// the class has been optimized to minimize the number of copies made
// while evaluating such an expression.  It contains a unique_ptr and
// the class has move semantics like a unique_ptr.

#include "FWCore/Utilities/interface/value_ptr.h"
#include "FWCore/ParameterSet/interface/ParameterDescriptionNode.h"

#include <map>
#include <memory>
#include <string>
#include <utility>

namespace edm {

  template<typename T>
  class ParameterDescriptionCases {
  public:
    typedef std::map<T, edm::value_ptr<ParameterDescriptionNode> > CaseMap;

    void insert(T caseValue, std::unique_ptr<ParameterDescriptionNode> node) {
      std::pair<T, edm::value_ptr<ParameterDescriptionNode> > casePair(caseValue,edm::value_ptr<ParameterDescriptionNode>());
      std::pair<typename CaseMap::iterator,bool> status;
      status = caseMap_->insert(casePair);
      (*caseMap_)[caseValue] = std::move(node);
      if (status.second == false) duplicateCaseValues_ = true;
    }

    std::unique_ptr<CaseMap> caseMap() { return std::move(caseMap_); }
    bool duplicateCaseValues() const { return duplicateCaseValues_; }

  private:

    friend
    std::unique_ptr<ParameterDescriptionCases<bool> >
    operator>>(bool caseValue,
               std::unique_ptr<ParameterDescriptionNode> node);

    friend
    std::unique_ptr<ParameterDescriptionCases<int> >
    operator>>(int caseValue,
               std::unique_ptr<ParameterDescriptionNode> node);

    friend
    std::unique_ptr<ParameterDescriptionCases<std::string> >
    operator>>(std::string const& caseValue,
               std::unique_ptr<ParameterDescriptionNode> node);

    friend
    std::unique_ptr<ParameterDescriptionCases<std::string> >
    operator>>(char const* caseValue,
               std::unique_ptr<ParameterDescriptionNode> node);

    // The constructor is intentionally private so that only the operator>> functions
    // can create these. 
    ParameterDescriptionCases(T const& caseValue, std::unique_ptr<ParameterDescriptionNode> node) :
      caseMap_(new CaseMap),
      duplicateCaseValues_(false)
    {
      std::pair<T, edm::value_ptr<ParameterDescriptionNode> > casePair(caseValue,edm::value_ptr<ParameterDescriptionNode>());
      caseMap_->insert(casePair);
      (*caseMap_)[caseValue] = std::move(node);
    }

    std::unique_ptr<CaseMap> caseMap_;
    bool duplicateCaseValues_;
  };

  std::unique_ptr<ParameterDescriptionCases<bool> >
  operator||(std::unique_ptr<ParameterDescriptionCases<bool> >,
             std::unique_ptr<ParameterDescriptionCases<bool> >);

  std::unique_ptr<ParameterDescriptionCases<int> >
  operator||(std::unique_ptr<ParameterDescriptionCases<int> >,
             std::unique_ptr<ParameterDescriptionCases<int> >);

  std::unique_ptr<ParameterDescriptionCases<std::string> >
  operator||(std::unique_ptr<ParameterDescriptionCases<std::string> >,
         std::unique_ptr<ParameterDescriptionCases<std::string> >);
}
#endif