ParameterDescriptionBase.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     ParameterSet
// Class  :     ParameterDescriptionBase
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones
//         Created:  Thu Aug  2 15:35:43 EDT 2007
//

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

#include <iostream>
#include <iomanip>

namespace edm {

  ParameterDescriptionBase::ParameterDescriptionBase(std::string const& iLabel,
                                                     ParameterTypes iType,
                                                     bool isTracked,
                                                     bool hasDefault)
    :label_(iLabel),
     type_(iType),
     isTracked_(isTracked),
     hasDefault_(hasDefault)
  {
    if(label_.empty()) {
      throw edm::Exception(errors::LogicError)
        << "Empty string used as a label for a parameter.  This is\n"
           "not allowed.\n";
    }
  }

  ParameterDescriptionBase::ParameterDescriptionBase(char const* iLabel,
                                                     ParameterTypes iType,
                                                     bool isTracked,
                                                     bool hasDefault)
    :label_(iLabel),
     type_(iType),
     isTracked_(isTracked),
     hasDefault_(hasDefault)
  {
    if (label_.empty()) {
      throw edm::Exception(errors::LogicError)
        << "Empty string used as a label for a parameter.  This is\n"
           "not allowed.\n";
    }
  }

  ParameterDescriptionBase::~ParameterDescriptionBase() { }

  void
  ParameterDescriptionBase::throwParameterWrongTrackiness() const {
    std::string tr("a tracked");
    std::string shouldBe("untracked");
    if (isTracked()) {
      tr = "an untracked";
      shouldBe = "tracked";
    }

    throw edm::Exception(errors::Configuration)
      << "In the configuration, parameter \"" << label() << "\" is defined "
      "as " << tr << " " << parameterTypeEnumToString(type()) << ".\n"
      << "It should be " << shouldBe << ".\n";
  }

  void
  ParameterDescriptionBase::throwParameterWrongType() const {
    std::string tr("an untracked");
    if (isTracked()) tr = "a tracked";

    throw edm::Exception(errors::Configuration)
      << "Parameter \"" << label() << "\" should be defined "
      "as " << tr << " " << parameterTypeEnumToString(type()) << ".\n"
      << "The type in the configuration is incorrect.\n";
  }

  void
  ParameterDescriptionBase::throwMissingRequiredNoDefault() const {

    std::string tr("untracked");
    if (isTracked()) tr = "tracked";

    throw edm::Exception(errors::Configuration)
      << "Missing required parameter.  It should have label \""
      << label() << "\" and have type \""
      << tr << " " << parameterTypeEnumToString(type()) << "\".\n"
      << "The description has no default.  The parameter must be defined "
         "in the configuration\n";
  }

  void
  ParameterDescriptionBase::
  checkAndGetLabelsAndTypes_(std::set<std::string> & usedLabels,
                             std::set<ParameterTypes> & parameterTypes,
                             std::set<ParameterTypes> & wildcardTypes) const {
    usedLabels.insert(label());
    parameterTypes.insert(type());
  }

  void
  ParameterDescriptionBase::
  validate_(ParameterSet & pset,
            std::set<std::string> & validatedLabels,
            bool optional) const {

    bool exists = exists_(pset, isTracked());

    if (exists) {
      validatedLabels.insert(label());
    }
    else if (exists_(pset, !isTracked())) {
      throwParameterWrongTrackiness();
    }
    else if (pset.exists(label())) {
      throwParameterWrongType();
    }

    if (!exists && !optional) {
      if (hasDefault()) {
        insertDefault_(pset);
        validatedLabels.insert(label());
      }
      else {
        throwMissingRequiredNoDefault();
      }
    }
  }

  void
  ParameterDescriptionBase::
  writeCfi_(std::ostream & os,
           bool & startWithComma,
           int indentation,
           bool & wroteSomething) const {

    if (!hasDefault()) return;

    wroteSomething = true;
    if (startWithComma) os << ",";
    startWithComma = true;

    os << "\n";
    printSpaces(os, indentation);

    os << label()
       << " = cms.";
    if (!isTracked()) os << "untracked.";
    os << parameterTypeEnumToString(type())
       << "(";
    writeCfi_(os, indentation);
    os << ")";
  }

  void
  ParameterDescriptionBase::
  print_(std::ostream & os,
         bool optional,
     bool writeToCfi,
         DocFormatHelper & dfh)
  {
    if (dfh.pass() == 0) {
      dfh.setAtLeast1(label().size());
      if (isTracked()) {
        dfh.setAtLeast2(parameterTypeEnumToString(type()).size());
      }
      else {
        dfh.setAtLeast2(parameterTypeEnumToString(type()).size() + 10U);
      }
      if (optional) {
        dfh.setAtLeast3(8U);
      }
    }
    else {

      if (dfh.brief()) {
        std::ios::fmtflags oldFlags = os.flags();

        dfh.indent(os);
        os << std::left << std::setw(dfh.column1()) << label() << " ";

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

        os << std::setw(dfh.column3());
        if (optional) {
          os << "optional";
        }
        else {
          os << "";
        }
        os << " ";
        os.flags(oldFlags);
        printDefault_(os, writeToCfi, dfh);
      }
      // not brief
      else {

        dfh.indent(os);
        os << label() << "\n";

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

        if (optional)  os << "optional";
        os << "\n";

        dfh.indent2(os);
        printDefault_(os, writeToCfi, dfh);

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

  void
  ParameterDescriptionBase::
  printDefault_(std::ostream & os,
                  bool writeToCfi,
                  DocFormatHelper & dfh) {
    if (!dfh.brief()) os << "default: ";
    if (writeToCfi && hasDefault()) {
      if (hasNestedContent()) {
        os << "see Section " << dfh.section()
           << "." << dfh.counter();
      }
      else {
        if (dfh.brief()) {
          writeDoc_(os, dfh.indentation());
        }
        else {
          writeDoc_(os, dfh.startColumn2());
        }
      }
    }
    else {
      os << "none (do not write to cfi)";
    }
    os << "\n";
  }

  void
  ParameterDescriptionBase::
  printNestedContent_(std::ostream & os,
                      bool optional,
                      DocFormatHelper & dfh) {
    int indentation = dfh.indentation();
    if (dfh.parent() != DocFormatHelper::TOP) {
      indentation -= DocFormatHelper::offsetSectionContent();
    }

    printSpaces(os, indentation);
    os << "Section " << dfh.section() << "." << dfh.counter()
       << " " << label() << " default contents: ";
    writeDoc_(os, indentation + 2);
    os << "\n";
    if (!dfh.brief()) os << "\n";
  }

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

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