C++ OptionalAttribute类代码示例

 int SamplingAlgorithmOptions_Impl::samples() const {
   int result;
   OptionalAttribute option = getOption("samples");
   BOOST_ASSERT(option);
   result = option->valueAsInteger();
   return result;
 }

 double OutputAttributeVariable_Impl::getValue(const DataPoint& dataPoint) const {
   OptionalAttribute oa = dataPoint.getOutputAttribute(m_attributeName);
   if (!oa) {
     LOG_AND_THROW("Unable to retrieve attribute '" << m_attributeName << "' for DataPoint at "
                   << toString(dataPoint.directory()) << ".");
   }
   Attribute attribute = oa.get();
   OptionalDouble result;
   AttributeValueType valueType = attribute.valueType();
   if (valueType == AttributeValueType::Double) {
     result = attribute.valueAsDouble();
   }
   if (valueType == AttributeValueType::Quantity) {
     result = attribute.valueAsQuantity().value();
   }
   if (valueType == AttributeValueType::Integer) {
     result = double(attribute.valueAsInteger());
   }
   if (valueType == AttributeValueType::Unsigned) {
     result = double(attribute.valueAsUnsigned());
   }
   if (!result) {
     LOG_AND_THROW("Unable to extract double value from attribute '" << m_attributeName
                   << "' of type " << valueType.valueDescription() << ".");
   }
   return *result;
 }

  bool SamplingAlgorithmOptions_Impl::setSamples(int value) {
	  if (value < 1) {
      LOG(Warn,"Cannot set SamplingAlgorithmOptions samples to a value less than one.");
      return false;
	  }
    OptionalAttribute option = getOption("samples");
    BOOST_ASSERT(option);
    option->setValue(value);
    return true;
  }

 void DDACEAlgorithmOptions_Impl::setSeed(int value){
   OptionalAttribute option;
   if ((option = getOption("seed"))) {
     option->setValue(value);
   }
   else {
     option = Attribute("seed",value);
     saveOption(*option);
   }
 }

 bool DDACEAlgorithmOptions_Impl::setSymbols(int value) {
   OptionalAttribute option;
   if ((option = getOption("symbols"))) {
     option->setValue(value);
   }
   else {
     option = Attribute("symbols",value);
     saveOption(*option);
   }
   return true;
 }

void OSIntegerEdit::refreshTextAndLabel() {
  if (m_modelObject) {
    QString textValue;
    ModelObject modelObject = m_modelObject.get();
    std::stringstream ss;

    if (m_isAutosizedProperty) {
      Attribute autosized = modelObject.getAttribute(*m_isAutosizedProperty).get();
      if (autosized.valueAsBoolean()) {
        textValue = QString("autosize");
      }
    }

    if (m_isAutocalculatedProperty) {
      Attribute autocalculated = modelObject.getAttribute(*m_isAutocalculatedProperty).get();
      if (autocalculated.valueAsBoolean()) {
        textValue = QString("autocalculate");
      }
    }

    OptionalAttribute attribute = modelObject.getAttribute(m_property);
    if (attribute) {
      int value = attribute->valueAsInteger();
      if (m_isScientific) {
        ss << std::scientific;
      }
      else {
        ss << std::fixed;
      }
      if (m_precision) {
        ss << std::setprecision(*m_precision);
      }
      ss << value;
      textValue = toQString(ss.str());
      ss.str("");
    }

    this->setText(textValue);

    if (m_isDefaultedProperty) {
      Attribute defaulted = modelObject.getAttribute(*m_isDefaultedProperty).get();
      if (defaulted.valueAsBoolean()) {
        this->setStyleSheet("color:green");
      }
      else {
        this->setStyleSheet("color:black");
      }
    }
  }
}

 bool ParameterStudyAlgorithmOptions_Impl::setNumSteps(int value) {
   if (value < 1) {
     LOG(Warn,"Cannot set ParameterStudyAlgorithmOptions numSteps to a value less than one.");
     return false;
   }
   OptionalAttribute option;
   if ((option = getOption("numSteps"))) {
     option->setValue(value);
   }
   else {
     option = Attribute("numSteps",value);
     saveOption(*option);
   }
   return true;
 }

 bool PSUADEDaceAlgorithmOptions_Impl::setSamples(int value) {
   if (value < 1) {
     LOG(Warn,"Cannot set PSUADEDaceAlgorithmOptions samples to a value less than one.");
     return false;
   }
   OptionalAttribute option;
   if ((option = getOption("samples"))) {
     option->setValue(value);
   }
   else {
     option = Attribute("samples",value);
     saveOption(*option);
   }
   return true;
 }

TEST_F(DataFixture, Attribute_Source) {
  AttributeVector attributes;

  // create vector of attributes with no sources
  attributes.push_back(Attribute("My Boolean Attribute",false));
  attributes.push_back(Attribute("My Double Attribute",34.2,"W"));
  attributes.push_back(Attribute("My Integer Attribute",5));
  attributes.push_back(Attribute("My String Attribute","flat finish"));
  attributes.push_back(Attribute("tricky_source","don't talk back"));

  // xml and back
  Attribute container("Containing Attribute",attributes);
  QDomDocument doc = container.toXml();
  OptionalAttribute containerCopy = Attribute::loadFromXml(doc);
  ASSERT_TRUE(containerCopy);
  AttributeVector attributesCopy = containerCopy.get().valueAsAttributeVector();
  EXPECT_EQ(attributes.size(),attributesCopy.size());
  for (const Attribute& attributeCopy : attributesCopy) {
    EXPECT_TRUE(attributeCopy.source().empty());
  }

  // json and back
  QVariant variant = detail::toVariant(attributes);
  int n = variant.toMap().size();
  attributesCopy = detail::toVectorOfAttribute(variant,VersionString(openStudioVersion()));
  EXPECT_EQ(attributes.size(),attributesCopy.size());
  for (const Attribute& attributeCopy : attributesCopy) {
    EXPECT_TRUE(attributeCopy.source().empty());
  }

  // apply same source to all attributes
  for (Attribute& attribute : attributes) {
    attribute.setSource("big data set");
  }

  // xml and back
  doc = container.toXml();
  containerCopy = Attribute::loadFromXml(doc);
  ASSERT_TRUE(containerCopy);
  attributesCopy = containerCopy.get().valueAsAttributeVector();
  EXPECT_EQ(attributes.size(),attributesCopy.size());
  for (const Attribute& attributeCopy : attributesCopy) {
    EXPECT_EQ("big data set",attributeCopy.source());
  }

  // json and back
  variant = detail::toVariant(attributes);
  EXPECT_EQ(n+1,variant.toMap().size());
  attributesCopy = detail::toVectorOfAttribute(variant,VersionString(openStudioVersion()));
  EXPECT_EQ(attributes.size(),attributesCopy.size());
  for (const Attribute& attributeCopy : attributesCopy) {
    EXPECT_EQ("big data set",attributeCopy.source());
  }

  // change one attribute's source to something different
  attributes[2].setSource("a wiki");

  // xml and back
  doc = container.toXml();
  containerCopy = Attribute::loadFromXml(doc);
  ASSERT_TRUE(containerCopy);
  attributesCopy = containerCopy.get().valueAsAttributeVector();
  EXPECT_EQ(attributes.size(),attributesCopy.size());
  for (const Attribute& attributeCopy : attributesCopy) {
    EXPECT_FALSE(attributeCopy.source().empty());
  }
  EXPECT_EQ("a wiki",attributesCopy[2].source());

  // json and back
  variant = detail::toVariant(attributes);
  EXPECT_EQ(n+attributes.size(),variant.toMap().size());
  attributesCopy = detail::toVectorOfAttribute(variant,VersionString(openStudioVersion()));
  EXPECT_EQ(attributes.size(),attributesCopy.size());
  for (const Attribute& attributeCopy : attributesCopy) {
    EXPECT_FALSE(attributeCopy.source().empty());
  }
  // order is not guaranteed

}

 int SequentialSearchOptions_Impl::objectiveToMinimizeFirst() const {
   OptionalAttribute option = getOption("objectiveToMinimizeFirst");
   BOOST_ASSERT(option);
   return option->valueAsInteger();
 }