FormGenAcceptResult FormGenRecordComposition::acceptsValueImpl(const QVariant &val) const { if( variantType(val) != QMetaType::QVariantHash ) return FormGenAcceptResult::reject({}, val); QVariantHash hash = val.toHash(); QStringList valueStringList; QSet<QString> processedTags; for( const auto &elm : mElements ) { auto elementAccepts = elm.element->acceptsValue(hash.value(elm.tag)); if( ! elementAccepts.acceptable ) { QString path = elm.tag; if( ! elementAccepts.path.isEmpty() ) path += QString("/%1").arg(elementAccepts.path); return FormGenAcceptResult::reject(path, elementAccepts.value); } valueStringList.append(FormGenElement::keyStringValuePair(elm.tag, elementAccepts.valueString)); processedTags.insert(elm.tag); } QSet<QString> remainingTags = hash.keys().toSet() - processedTags; if( ! remainingTags.isEmpty() ) return FormGenAcceptResult::reject(*remainingTags.cbegin(), hash.value(*remainingTags.cbegin())); return FormGenAcceptResult::accept(val, FormGenElement::objectString(valueStringList)); }
FormGenAcceptResult FormGenListBagComposition::acceptsValueImpl(const QVariant &val) const { if( variantType(val) != QMetaType::QVariantList ) return FormGenAcceptResult::reject({}, val); const QVariantList list = val.toList(); if( list.size() > 0 && mElement == nullptr ) return FormGenAcceptResult::reject({}, val); QStringList valueStrings; for( int i = 0; i < list.size(); ++i ) { auto elementAccepts = mElement->acceptsValue(list.at(i)); if( ! elementAccepts.acceptable ) { QString path = QString::number(i); if( ! elementAccepts.path.isEmpty() ) path += QString("/%1").arg(elementAccepts.path); return FormGenAcceptResult::reject(path, elementAccepts.value); } valueStrings.append(elementAccepts.valueString); } return FormGenAcceptResult::accept(val, joinedValueStringList(valueStrings)); }
bool Variant::xmlRead(QDomNode& node) { bool ok = node.isElement(); if (ok) { VariantType vt = variantType(xmlTypeAttr(node)); ok = node.toElement().tagName().toUtf8() == xmlTagName && vt != 0; if (ok) { VariantData* vd = construct(vt); if (vd) { ok = vd->xmlRead(node); if (ok) *this = vd; else vd->release(); } else ok = VariantBase::xmlRead(node); } } return ok; }
double Variant::operator = (double val) { LongReal* vr = static_cast<LongReal*>(construct(variantType(nLongReal))); *vr = val; if (vr->isNaN()) { vr->release(); *this = InvalidParam; } else *this = vr; return val; }
/** * \brief Convert a QVariant type to a CAMP type * * \param theType Source QVariant type to convert * * \return \a theType converted to a camp::Type */ static camp::Type type(QVariant::Type theType) { // We add an extra conversion to QVariant::Type because variant.type() may return metatypes // that do not exist in QVariant (such as QMetaType::Long which is considered a user type) switch (variantType(theType)) { case QVariant::Invalid: return camp::noType; case QVariant::Bool: return camp::boolType; case QVariant::Char: return camp::intType; case QVariant::Int: return camp::intType; case QVariant::LongLong: return camp::intType; case QVariant::UInt: return camp::intType; case QVariant::ULongLong: return camp::intType; case QVariant::Double: return camp::realType; case QVariant::String: return camp::stringType; default: return camp::noType; } }
/** * \brief Convert a QVariant to a CAMP value * * \param variant Source QVariant to convert * * \return \a variant converted to a camp::Value */ static camp::Value variantToValue(const QVariant& variant) { // We add an extra conversion to QVariant::Type because variant.type() may return metatypes // that do not exist in QVariant (such as QMetaType::Long which is considered a user type) switch (variantType(variant.type())) { default: case QVariant::Invalid: return camp::Value(); case QVariant::Bool: return camp::Value(variant.toBool()); case QVariant::Char: return camp::Value(variant.toInt()); case QVariant::Int: return camp::Value(variant.toInt()); case QVariant::LongLong: return camp::Value(variant.toLongLong()); case QVariant::UInt: return camp::Value(variant.toUInt()); case QVariant::ULongLong: return camp::Value(variant.toULongLong()); case QVariant::Double: return camp::Value(variant.toDouble()); case QVariant::String: return camp::Value(variant.toString()); } }
static ObjectPtr convertObject(ObjectPtr x) { switch (x->objKind) { case RECORD_DECL : { RecordDecl *y = (RecordDecl *)x.ptr(); if (y->params.empty() && !y->varParam.ptr()) return recordType(y, vector<ObjectPtr>()).ptr(); return x; } case VARIANT_DECL : { VariantDecl *y = (VariantDecl *)x.ptr(); if (y->params.empty() && !y->varParam.ptr()) return variantType(y, vector<ObjectPtr>()).ptr(); return x; } default : return x; } }
void FormGenChoiceComposition::setVaidatedValueImpl(const QVariant &val) { int idx; QVariant choiceVal; if( variantType(val) == QMetaType::QVariantMap ) { auto map = val.toMap(); idx = mTagIndexMap.value(map.cbegin().key()); choiceVal = map.cbegin().value(); } else { auto map = val.toHash(); idx = mTagIndexMap.value(map.cbegin().key()); choiceVal = map.cbegin().value(); } mContainer->setCurrentIndex(idx); mElements.at(idx).element->setValidatedValue(choiceVal); }
FormGenAcceptResult FormGenChoiceComposition::acceptsValueImpl(const QVariant &val) const { if( variantType(val) != QMetaType::QVariantHash ) return FormGenAcceptResult::reject({}, val); QVariantHash hash = val.toHash(); if( hash.size() != 1 ) return FormGenAcceptResult::reject({}, hash); auto it = mTagIndexMap.find(hash.cbegin().key()); if( it == mTagIndexMap.cend() ) return FormGenAcceptResult::reject({}, hash); auto elementAccepts = mElements.at(it.value()).element->acceptsValue(hash.cbegin().value()); if( ! elementAccepts.acceptable ) { QString path = it.key(); if( ! elementAccepts.path.isEmpty() ) path += QString("/%1").arg(elementAccepts.path); return FormGenAcceptResult::reject(path, elementAccepts.value); } QString keyValue = FormGenElement::keyStringValuePair(it.key(), elementAccepts.valueString); return FormGenAcceptResult::accept(val, FormGenElement::objectString(QStringList({keyValue}))); }
/** * \brief Extract the CAMP type of a Qt type in string form * * \param typeName Qt type * * \return Corresponding CAMP type */ static camp::Type type(const char* typeName) { return type(variantType(QMetaType::type(typeName))); }
variantType convertToVariant(const origType &val) { return variantType(val); }