/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_14/src/FWCore/ParameterSet/src/ParameterSwitchBase.cc

Go to the documentation of this file.

#include "FWCore/ParameterSet/interface/ParameterSwitchBase.h"

#include "FWCore/ParameterSet/interface/DocFormatHelper.h"
#include "FWCore/Utilities/interface/EDMException.h"

#include <iomanip>
#include <ostream>
#include <sstream>

namespace edm {

  ParameterSwitchBase::~ParameterSwitchBase() { }

  void
  ParameterSwitchBase::
  throwDuplicateCaseValues(std::string const& switchLabel) const {
    throw Exception(errors::LogicError)
      << "When adding a ParameterSwitch to a ParameterSetDescription the values\n"
      << "associated with the different cases must be unique.  Duplicate\n"
      << "values were found for the switch with label: \"" << switchLabel
      << "\"\n";
  }

  void
  ParameterSwitchBase::
  insertAndCheckLabels(std::string const& switchLabel,
                       std::set<std::string>& usedLabels,
                       std::set<std::string>& labels) const {

    std::pair<std::set<std::string>::iterator,bool> status = labels.insert(switchLabel);
    if(status.second == false) {
      throw Exception(errors::LogicError)
        << "The label used for the switch parameter in a ParameterSetDescription\n"
        << "must be different from the labels used in the associated cases.  The following\n"
        << "duplicate label was found: \"" << switchLabel << "\"\n";
    }
    usedLabels.insert(labels.begin(), labels.end());
  }

  void
  ParameterSwitchBase::
  insertAndCheckTypes(ParameterTypes switchType,
                      std::set<ParameterTypes> const& caseParameterTypes,
                      std::set<ParameterTypes> const& caseWildcardTypes,
                      std::set<ParameterTypes>& parameterTypes,
                      std::set<ParameterTypes>& wildcardTypes) const {

    if(caseWildcardTypes.find(switchType) != caseWildcardTypes.end()) {
      throw Exception(errors::LogicError)
        << "The type used for the switch parameter in a ParameterSetDescription\n"
        << "must be different from the types used for wildcards in the associated cases.  The following\n"
        << "duplicate type was found: \"" << parameterTypeEnumToString(switchType) << "\"\n";
    }
    parameterTypes.insert(switchType);
    parameterTypes.insert(caseParameterTypes.begin(), caseParameterTypes.end());
    wildcardTypes.insert(caseWildcardTypes.begin(), caseWildcardTypes.end());
  }

  void
  ParameterSwitchBase::
  throwNoCaseForDefault(std::string const& switchLabel) const {
    throw Exception(errors::LogicError)
      << "The default value used for the switch parameter in a ParameterSetDescription\n"
      << "must match the value used to select one of the associated cases.  This is not\n"
      << "true for the switch named \"" << switchLabel << "\"\n";
  }

  void
  ParameterSwitchBase::
  throwNoCaseForSwitchValue(std::string const& message) const {
    throw Exception(errors::Configuration)
      << message;
  }

  void
  ParameterSwitchBase::
  printBase(std::ostream& os,
            bool optional,
            bool writeToCfi,
            DocFormatHelper& dfh,
            std::string const& switchLabel,
            bool isTracked,
            std::string const& typeString) const {

    if(dfh.pass() == 0) {
      dfh.setAtLeast1(switchLabel.size() + 9U);
      if(isTracked) {
        dfh.setAtLeast2(typeString.size());
      } else {
        dfh.setAtLeast2(typeString.size() + 10U);
      }
      dfh.setAtLeast3(8U);
    }
    if(dfh.pass() == 1) {

      dfh.indent(os);

      if(dfh.brief()) {

        std::stringstream ss;
        ss << switchLabel << " (switch)";
        std::ios::fmtflags oldFlags = os.flags();
        os << std::left << std::setw(dfh.column1()) << ss.str();
        os << " ";

        os << std::setw(dfh.column2());
        if(isTracked) {
          os << typeString;
        } else {
          std::stringstream ss1;
          ss1 << "untracked " << typeString;
          os << ss1.str();
        }

        os << " " << std::setw(dfh.column3());
        if(optional)  os << "optional";
        else  os << "";

        if(!writeToCfi) os << " (do not write to cfi)";

        os << " see Section " << dfh.section() << "." << dfh.counter() << "\n";
        os.flags(oldFlags);
      } else {
        // not brief

        os << switchLabel << " (switch)\n";

        dfh.indent2(os);
        os << "type: ";
        if(!isTracked) os << "untracked ";
        os << typeString << " ";

        if(optional)  os << "optional";

        if(!writeToCfi) os << " (do not write to cfi)";
        os << "\n";

        dfh.indent2(os);
        os << "see Section " << dfh.section() << "." << dfh.counter() << "\n";

        if(!comment().empty()) {
          DocFormatHelper::wrapAndPrintText(os,
                                            comment(),
                                            dfh.startColumn2(),
                                            dfh.commentWidth());
        }
        os << "\n";
      }
    }
  }

  bool
  ParameterSwitchBase::
  hasNestedContent_() {
    return true;
  }

  void
  ParameterSwitchBase::
  printNestedContentBase(std::ostream& os,
                         DocFormatHelper& dfh,
                         DocFormatHelper& new_dfh,
                         std::string const& switchLabel) {

    int indentation = dfh.indentation();
    if(dfh.parent() != DocFormatHelper::TOP) {
      indentation -= DocFormatHelper::offsetSectionContent();
    }

    std::stringstream ss;
    ss << dfh.section() << "." << dfh.counter();
    std::string newSection = ss.str();

    printSpaces(os, indentation);
    os << "Section " << newSection
       << " " << switchLabel << " (switch):\n";

    if(!dfh.brief()) {
      printSpaces(os, indentation);
      os << "The value of \"" << switchLabel << "\" controls which other parameters\n";
      printSpaces(os, indentation);
      os << "are required or allowed to be in the PSet.\n";
    }
    if(!dfh.brief()) os << "\n";

    new_dfh.init();
    new_dfh.setSection(newSection);
    new_dfh.setIndentation(indentation + DocFormatHelper::offsetSectionContent());
    new_dfh.setParent(DocFormatHelper::OTHER);
  }


  void
  ParameterSwitchBase::
  printCase(std::pair<bool, value_ptr<ParameterDescriptionNode> > const& p,
            std::ostream& os,
            bool /*optional*/,
            DocFormatHelper& dfh,
            std::string const& switchLabel) {
    if(dfh.pass() == 0) {
      p.second->print(os, false, true, dfh);
    }
    if(dfh.pass() == 1) {
      dfh.indent(os);
      os << "if " << switchLabel << " = ";
      if(p.first) os << "True";
      else os << "False";
      os << "\n";
      p.second->print(os, false, true, dfh);
    }
    if(dfh.pass() == 2) {
      p.second->printNestedContent(os, false, dfh);
    }
  }

  void
  ParameterSwitchBase::
  printCase(std::pair<int, value_ptr<ParameterDescriptionNode> > const& p,
            std::ostream& os,
            bool /*optional*/,
            DocFormatHelper& dfh,
            std::string const& switchLabel) {
    if(dfh.pass() == 0) {
      p.second->print(os, false, true, dfh);
    }
    if(dfh.pass() == 1) {
      dfh.indent(os);
      os << "if " << switchLabel << " = " << p.first << "\n";
      p.second->print(os, false, true, dfh);
    }
    if(dfh.pass() == 2) {
      p.second->printNestedContent(os, false, dfh);
    }
  }

  void
  ParameterSwitchBase::
  printCase(std::pair<std::string, value_ptr<ParameterDescriptionNode> > const& p,
            std::ostream& os,
            bool /*optional*/,
            DocFormatHelper& dfh,
            std::string const& switchLabel) {
    if(dfh.pass() == 0) {
      p.second->print(os, false, true, dfh);
    }
    if(dfh.pass() == 1) {
      dfh.indent(os);
      os << "if " << switchLabel << " = \"" << p.first << "\"\n";
      p.second->print(os, false, true, dfh);
    }
    if(dfh.pass() == 2) {
      p.second->printNestedContent(os, false, dfh);
    }
  }

  bool
  ParameterSwitchBase::
  partiallyExists_(ParameterSet const& pset) const {
    return exists(pset);
  }

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