C++ Option::getName方法代码示例

TEST(OptionsTest, test_option_writing)
{
    std::ostringstream ostr_i;
    const std::string ref_i = xml_header + xml_int_ref;
    std::ostringstream ostr_s;
    const std::string ref_s = xml_header + xml_str_ref;

    const Option option_i("my_int", (uint16_t)17,
        "This is my integral option.");
    EXPECT_TRUE(option_i.getName() == "my_int");
    EXPECT_TRUE(option_i.getDescription() == "This is my integral option.");
    EXPECT_TRUE(option_i.getValue<uint16_t>() == 17);
    EXPECT_TRUE(option_i.getValue<std::string>() == "17");

    const Option option_s("my_string", "Yow.", "This is my stringy option.");
    EXPECT_TRUE(option_s.getName() == "my_string");
    EXPECT_TRUE(option_s.getDescription() == "This is my stringy option.");
    EXPECT_TRUE(option_s.getValue<std::string>() == "Yow.");
    EXPECT_TRUE(option_s.getValue<std::string>() == "Yow.");

//     const pdalboost::property_tree::ptree tree_i = Utils::toPTree(option_i);
//     pdalboost::property_tree::xml_parser::write_xml(ostr_i, tree_i);
//     const std::string str_i = ostr_i.str();
//     EXPECT_TRUE(str_i == ref_i);
//
//     const pdalboost::property_tree::ptree tree_s = Utils::toPTree(option_s);
//     pdalboost::property_tree::xml_parser::write_xml(ostr_s, tree_s);
//     const std::string str_s = ostr_s.str();
//     EXPECT_TRUE(str_s == ref_s);
}

/*********************************************************************
 ** METHOD  :
 ** PURPOSE :
 ** INPUT   :
 ** OUTPUT  :
 ** RETURN  :
 ** REMARKS :
 *********************************************************************/
void OptionsHelpVisitor::visitOption (Option& object, size_t depth)
{
    if (!object.getName().empty() && object.isVisible())
    {
        if (object.getNbArgs() > 0)
        {
            indent(os,depth) << Stringify::format ("    %-*s (%d arg) :    %s",
                (int)nameMaxLen,
                object.getName().c_str(),
                (int)object.getNbArgs(),
                object.getHelp().c_str(),
                object.getDefaultValue().c_str()
            );

            if (object.isMandatory()==false)  {  os << Stringify::format ("  [default '%s']", object.getDefaultValue().c_str());  }

            os << endl;
        }
        else
        {
            indent(os,depth) << Stringify::format ("    %-*s (%d arg) :    %s\n",
                (int)nameMaxLen,
                object.getName().c_str(),
                (int)object.getNbArgs(),
                object.getHelp().c_str()
            );
        }
    }
}

TEST(OptionsTest, test_option_writing)
{
    const Option option_i("my_int", (uint16_t)17);
    EXPECT_TRUE(option_i.getName() == "my_int");
    EXPECT_TRUE(option_i.getValue() == "17");

    const Option option_s("my_string", "Yow.");
    EXPECT_TRUE(option_s.getName() == "my_string");
    EXPECT_TRUE(option_s.getValue() == "Yow.");
    EXPECT_TRUE(option_s.getValue() == "Yow.");
}

void InputDialog::initializeControl(Option const& opt, QRadioButton* radio) 
{
   connectControl(opt, radio);
   radio->setToolTip(prependRemName(opt.getName(), opt.getDescription()));

   Action* action = new Action(
      boost::bind(&QRadioButton::setChecked, radio, opt.getDefaultIndex()) );
   m_resetActions.push_back(action);

   Update* update = new Update(
      boost::bind( 
         static_cast<void(*)(QRadioButton*, QString const&)>(SetControl), radio, _1));
   QString name = opt.getName();
   m_setUpdates[name] = update;
}

/// @name Equality
    /// Equality
    bool equals(const Option& rhs) const
    {
        return (m_name == rhs.getName() &&
            m_value == rhs.getValue<std::string>() &&
            m_description == rhs.getDescription() &&
            m_options == rhs.m_options);
    }

TEST(OptionsTest, test_option_writing)
{
    std::ostringstream ostr_i;
    const std::string ref_i = xml_header + xml_int_ref;
    std::ostringstream ostr_s;
    const std::string ref_s = xml_header + xml_str_ref;

    const Option option_i("my_int", (uint16_t)17);
    EXPECT_TRUE(option_i.getName() == "my_int");
    EXPECT_TRUE(option_i.getValue() == "17");

    const Option option_s("my_string", "Yow.");
    EXPECT_TRUE(option_s.getName() == "my_string");
    EXPECT_TRUE(option_s.getValue() == "Yow.");
    EXPECT_TRUE(option_s.getValue() == "Yow.");
}

bool Option::operator<(Option &aOther)
{
  if (name_ == 0 && aOther.getName() != 0)
    return false;
  else if (name_ != 0 && aOther.getName() == 0)
    return true;
  else if (name_ == 0 && aOther.getName() == 0)
  {
    if (order_ == -1)
      return false;
    if (aOther.getOrder() == -1)
      return true;
    
    return order_ < aOther.getOrder();
  }
  
  return strcmp(name_, aOther.getName()) < 0;
}

Stage *PipelineReaderXML::parseElement_Writer(const ptree& tree)
{
    Options options;
    StageParserContext context;
    std::string filename;

    map_t attrs;
    collect_attributes(attrs, tree);

    std::vector<Stage *> prevStages;
    for (auto iter = tree.begin(); iter != tree.end(); ++iter)
    {
        const std::string& name = iter->first;
        const ptree& subtree = iter->second;

        if (name == "<xmlattr>")
        {
            // already parsed -- ignore it
        }
        else if (name == "Option")
        {
            Option option = parseElement_Option(subtree);
            if (option.getName() == "filename")
                filename = option.getValue();
            options.add(option);
        }
        else if (name == "Metadata")
        {
            // ignored
        }
        else if (name == "Filter" || name == "Reader")
        {
            context.addStage();
            prevStages.push_back(parseElement_anystage(name, subtree));
        }
        else
        {
            context.addUnknown(name);
        }
    }

    std::string type;
    if (attrs.count("type"))
    {
        type = attrs["type"];
        context.addType();
    }

    context.validate();
    Stage& writer = m_manager.makeWriter(filename, type);
    for (auto sp : prevStages)
        writer.setInput(*sp);
    writer.removeOptions(options);
    writer.addOptions(options);
    return &writer;
}

//! The connectControl routines make the necessary signal-slot connections
//! between the control, the current Job and Nodes in the OptionRegister (for
//! program logic purposes).
void InputDialog::connectControl(Option const& opt, QComboBox* combo) {
   QString name = opt.getName();

   connect(combo, SIGNAL(currentIndexChanged(const QString&)),
      this, SLOT(widgetChanged(const QString&)));

   if (combo->isEditable()) {
      connect(combo, SIGNAL(editTextChanged(const QString&)),
         this, SLOT(widgetChanged(const QString&)));
   }

//! The (overloaded) initializeControl routine is responsible for the following
//! tasks:
//!  - Ensuring the control displays the appropriate options based on the
//!    contents of the OptionDatabase.
//!  - Adding the ToolTip documentation found in the database.
//!  - Adding connections (signals & slots) between the Nodes in the
//!    OptionRegister and the control.  This allows for synchronization of the
//!    logic in InitializeQChemLogic and initializeQuiLogic.
//!  - Binding an Action to enable the control to be reset to the default value.
//!  - Binding an Update to enable the control to be reset to a string value.
void InputDialog::initializeControl(Option const& opt, QComboBox* combo) {

   QString name = opt.getName();
   QStringList opts = opt.getOptions();
   QStringList split;

   // This allows for ad hoc text replacements.  This is useful so that more
   // informative text can be presented to the user which is then obfiscated
   // before being passed to QChem.  The replacements should be set in the
   // option database and have the form text//replacement.
   for (int i = 0; i < opts.size(); ++i) {
       split = opts[i].split("//");

       if (split.size() == 1) {
          opts[i] = split[0];
       }else if (split.size() == 2) {
          opts[i] = split[0];
          QString key(name.toUpper() + "::" + split[0]);
          //Job::addAdHoc(key,split[1]);
          RemSection::addAdHoc(name, split[0], split[1]);
       }else {
          qDebug() << "InputDialog::initialiseComboBox:\n"
                   << " replacement for option" << name << "is invalid:" << opts[i];
       }
   }

   combo->clear();
   combo->addItems(opts);

#if QT_VERSION >= 0x040400
   // This just allows us to add some spacers to the lists
   bool keepLooking(true);
   while (keepLooking) {
      int i = combo->findText("---", Qt::MatchStartsWith);
      if (i > 0) {
         combo->removeItem(i);
         combo->insertSeparator(i);
      }else {
         keepLooking = false;
      }
   }
#endif

   connectControl(opt, combo);
   combo->setToolTip(opt.getDescription());

   Action* action = new Action(
      boost::bind(&QComboBox::setCurrentIndex, combo, opt.getDefaultIndex()) );
   m_resetActions.push_back(action);

   Update* update = new Update(
      boost::bind(
         static_cast<void(*)(QComboBox*, QString const&)>(SetControl), combo, _1));
   m_setUpdates[name] = update;
}

int OptionContainer::findOption(Option o) {
    int i=0;
    for ( OptionVectorIterator it = m_Options.begin();
      it != m_Options.end();
      ++it )
    {
        if((*it).getName() == o.getName()) {
            return i;
        }
        i++;
    }
    return -1;
}

//! Inserts an Option into the database, overwriting the record if the
//! option name already exists.  The user is prompted if an overwrite will
//! occur and if \var promptOnOverwrite is set to true.
bool OptionDatabase::insert(Option const& opt, bool const promptOnOverwrite)
{
    Option tmp;
    QString name(opt.getName());

    if ( get(name, tmp) ) {
        if (promptOnOverwrite) {
            QString msg("Option name ");
            msg += name;
            msg += " already exists in database, overwrite?";
            int ret = QMsgBox::question(0, "Option Exists",msg,
                                        QMessageBox::Ok | QMessageBox::Cancel);
            if (ret == QMessageBox::Cancel) {
                return false;
            }
        }
        remove(name,false);
    }

    QString buf("insert into options( 'Name', 'Type', 'Default', 'Options', "
                "'Description', 'Implementation' ) values ( '");
    buf += opt.getName() + "', ";
    buf += QString::number(opt.getType()) + ", ";
    buf += QString::number(opt.getDefaultIndex()) + ", '";
    buf += opt.getOptionString() + "', ";   // No quote!

    QSqlField desc("Description", QVariant::String);
    desc.setValue(opt.getDescription());
    buf += QSqlDatabase::database("QChem").driver()->formatValue(desc);
    buf += ", ";
    buf += QString::number(opt.getImplementation()) + ");";

    qDebug() << "Database insert: " << buf;

    return execute(buf);
}

TEST(OptionsTest, json)
{
    // Test that a JSON option will be stringified into the option's underlying
    // value.
    Json::Value inJson;
    inJson["key"] = 42;
    const Option option_j("my_json", inJson);
    EXPECT_TRUE(option_j.getName() == "my_json");

    // Don't string-compare, test JSON-equality, since we don't care exactly
    // how it's stringified.
    Json::Value outJson;
    Json::Reader().parse(option_j.getValue(), outJson);

    EXPECT_EQ(inJson, outJson) << inJson << " != " << outJson;
}

inline ptree toPTree(const Option& option)
{
    ptree t;
    t.put("Name", option.getName());
    t.put("Value", option.getValue<std::string>());
    if (option.getDescription() != "")
    {
        t.put("Description", option.getDescription());
    }
    boost::optional<Options const&> options = option.getOptions();

    if (options != boost::none)
    {
        t.add_child("Options", toPTree(*options));
    }
    return t;
}

void ConfTool::do_opts (bool annotated, bool changed) {
  (void)annotated;(void)changed;
  std::vector<const char*>* opts = ConfigManager::getOptions();
  size_t i;
  buffer_t value, valid;
  const char* name, *init, *type;

  if (!opts)
    return;

  buffer_init(&value);
  buffer_init(&valid);

  for (i = 0; i < opts->size(); i++) {
    buffer_shrink(&value,0);
    buffer_shrink(&valid,0);
    Option* opt = ConfigManager::get(opts->at(i));
    name = opt->getName();
    type = opt->getType();
    init = opt->getInit();
    opt->query(&value);
    if (!opt->validity(&valid))
      buffer_shrink(&valid,0);
    int eq = buffer_equal1 (&value,init,-1);
    Option::prettyValue(&value);
    if (changed && eq)
      continue;
    cout << name << " = \"" << (NONULL(value.str)) << "\"";
    if (annotated) {
      cout << " #";
      if (!eq)
        cout << " (default: \"" << (NONULL(init)) << "\")";
      cout << " (type: " << (NONULL(type)) << ")";
      if (valid.len)
        cout << " (validity: " << valid.str << ")";
    }
    cout << endl;
  }

  delete opts;
  buffer_free (&value);
  buffer_free (&valid);
}