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);
}
