C++ QVariantMap::isEmpty方法代码示例

/*
 * initialize OrderData from QVariantMap
 * Map got from JsonDataAccess or so
 * includes also transient values
 * uses foreign property names - per ex. from Server API
 * corresponding export method: toForeignMap()
 */
void Customer::fillFromForeignMap(const QVariantMap& customerMap)
{
	mId = customerMap.value(idForeignKey).toInt();
	mCompanyName = customerMap.value(companyNameForeignKey).toString();
	// mCoordinate points to GeoCoordinate*
	if (customerMap.contains(coordinateForeignKey)) {
		QVariantMap coordinateMap;
		coordinateMap = customerMap.value(coordinateForeignKey).toMap();
		if (!coordinateMap.isEmpty()) {
			mCoordinate = 0;
			mCoordinate = new GeoCoordinate();
			mCoordinate->setParent(this);
			mCoordinate->fillFromForeignMap(coordinateMap);
		}
	}
	// mGeoAddress points to GeoAddress*
	if (customerMap.contains(geoAddressForeignKey)) {
		QVariantMap geoAddressMap;
		geoAddressMap = customerMap.value(geoAddressForeignKey).toMap();
		if (!geoAddressMap.isEmpty()) {
			mGeoAddress = 0;
			mGeoAddress = new GeoAddress();
			mGeoAddress->setParent(this);
			mGeoAddress->fillFromForeignMap(geoAddressMap);
		}
	}
}

void NodeModel::fromVariantMap(const QVariantMap& map){

    QVariantList pos = map["Position"].toList();
    QVariantMap netDeviceMap = map["NetDevice"].toMap();
    QVariantMap noiseSourceMap = map["NoiseSource"].toMap();

    //Migration for older versions of the dgm files.
    if(netDeviceMap.isEmpty()){
        QVariantList netDevicesList = map["NetDevices"].toList();
        if(!netDevicesList.isEmpty()){
            netDeviceMap = netDevicesList.at(0).toMap();
        }
    }

    if(noiseSourceMap.isEmpty()){
        QVariantList noiseSourcesList = map["NoiseSources"].toList();
        if(!noiseSourcesList.isEmpty()){
            noiseSourceMap = noiseSourcesList.at(0).toMap();
        }
    }

    name = map["Name"].toString();
    position = QPointF(pos.at(0).toDouble(), pos.at(1).toDouble());

    if (!netDeviceMap.isEmpty()){
        netDevice = new NetDeviceModel(netDeviceMap);
    }

    if(!noiseSourceMap.isEmpty()){
        noiseSource = new NoiseSourceModel(noiseSourceMap);
    }

    this->hasOutlet = map["HasOutlet"].toBool();
    this->outletImpedance.setValue(map["OutletImpedance"].toString());
}

void
YTVideoUrlFetcher::onProcessFinished(int code, QProcess::ExitStatus status)
{
    qDebug() << "youtube-dl process finished, status:" << status
             << ", exit code:" << code;
    if (status == QProcess::NormalExit && code == 0) {
        QByteArray rawJson = _process->readAllStandardOutput();
        QJsonParseError error;
        QJsonDocument doc = QJsonDocument::fromJson(rawJson, &error);
        if (error.error != QJsonParseError::NoError) {
            qCritical() << "JSON parse error:" << error.errorString();
            emit failure();
        } else {
            Q_ASSERT(!doc.isNull());
            QVariantMap response = parseResponse(doc);
            if (!response.isEmpty()) {
                QVariantMap map = doc.toVariant().toMap();
                Q_ASSERT(!map.isEmpty() && map.contains("id"));
                _response_cache.insert(map["id"].toString(), new QVariantMap(response));
                emit success(response);
            } else {
                emit failure();
            }
        }
    } else {
        qCritical() << "YouTubeDL process did not finish cleanly:"
                    << _process->readAllStandardError();
        emit failure();
    }
    delete _process;
    _process = NULL;
}

int AddToolChainOperation::execute() const
{
    QVariantMap map = load(QLatin1String("toolchains"));
    if (map.isEmpty())
        map = initializeToolChains();

    QVariantMap result = addToolChain(map, m_id, m_displayName, m_path, m_targetAbi, m_supportedAbis, m_extra);
    if (result.isEmpty() || map == result)
        return 2;

    return save(result, QLatin1String("toolchains")) ? 0 : 3;
}

bool QgsAfsSourceSelect::connectToService( const QgsOwsConnection &connection )
{
  QString errorTitle, errorMessage;
  QVariantMap serviceInfoMap = QgsArcGisRestUtils::getServiceInfo( connection.uri().param( "url" ), errorTitle, errorMessage );
  if ( serviceInfoMap.isEmpty() )
  {
    QMessageBox::warning( this, tr( "Error" ), tr( "Failed to retrieve service capabilities:\n%1: %2" ).arg( errorTitle ).arg( errorMessage ) );
    return false;
  }

  QStringList layerErrors;
  foreach ( const QVariant& layerInfo, serviceInfoMap["layers"].toList() )
  {
    QVariantMap layerInfoMap = layerInfo.toMap();
    if ( !layerInfoMap["id"].isValid() )
    {
      continue;
    }

    // Get layer info
    QVariantMap layerData = QgsArcGisRestUtils::getLayerInfo( connection.uri().param( "url" ) + "/" + layerInfoMap["id"].toString(), errorTitle, errorMessage );
    if ( layerData.isEmpty() )
    {
      layerErrors.append( tr( "Layer %1: %2 - %3" ).arg( layerInfoMap["id"].toString() ).arg( errorTitle ).arg( errorMessage ) );
      continue;
    }
    // insert the typenames, titles and abstracts into the tree view
    QStandardItem* idItem = new QStandardItem( layerData["id"].toString() );
    QStandardItem* nameItem = new QStandardItem( layerData["name"].toString() );
    QStandardItem* abstractItem = new QStandardItem( layerData["description"].toString() );
    abstractItem->setToolTip( layerData["description"].toString() );
    QStandardItem* cachedItem = new QStandardItem();
    QStandardItem* filterItem = new QStandardItem();
    cachedItem->setCheckable( true );
    cachedItem->setCheckState( Qt::Checked );

    QgsCoordinateReferenceSystem crs = QgsArcGisRestUtils::parseSpatialReference( serviceInfoMap["spatialReference"].toMap() );
    if ( !crs.isValid() )
    {
      // If not spatial reference, just use WGS84
      crs.createFromString( "EPSG:4326" );
    }
    mAvailableCRS[layerData["name"].toString()] = QList<QString>()  << crs.authid();

    mModel->appendRow( QList<QStandardItem*>() << idItem << nameItem << abstractItem << cachedItem << filterItem );
  }
  if ( !layerErrors.isEmpty() )
  {
    QMessageBox::warning( this, tr( "Error" ), tr( "Failed to query some layers:\n%1" ).arg( layerErrors.join( "\n" ) ) );
  }
  return true;
}

int AddQtOperation::execute() const
{
    QVariantMap map = load(QLatin1String("qtversions"));
    if (map.isEmpty())
        map = initializeQtVersions();

    QVariantMap result = addQt(map, m_id, m_displayName, m_type, m_qmake, m_extra);

    if (result.isEmpty() || result == map)
        return 2;

    return save(result, QLatin1String("qtversions")) ? 0 : 3;
}

int AddDebuggerOperation::execute() const
{
    QVariantMap map = load(QLatin1String("Debuggers"));
    if (map.isEmpty())
        map = initializeDebuggers();

    QVariantMap result = addDebugger(map, m_id, m_displayName, m_engine, m_binary, m_abis,
                                     m_extra);

    if (result.isEmpty() || map == result)
        return 2;

    return save(result, QLatin1String("Debuggers")) ? 0 : 3;
}

int AddKitOperation::execute() const
{
    QVariantMap map = load(QLatin1String("profiles"));
    if (map.isEmpty())
        map = initializeKits();

    map = addKit(map, m_id, m_displayName, m_icon, m_debuggerEngine, m_debugger,
                 m_deviceType.toUtf8(), m_sysRoot, m_tc, m_qt, m_mkspec, m_extra);

    if (map.isEmpty())
        return -2;

    return save(map, QLatin1String("profiles")) ? 0 : -3;
}

static QVariantMap mergeMaps(const QVariantMap &map1,
                             const QVariantMap &map2)
{
    if (map1.isEmpty()) return map2;
    if (map2.isEmpty()) return map1;

    QVariantMap map = map1;
    //map2 values will overwrite map1 values for the same keys.
    QMapIterator<QString, QVariant> it(map2);
    while (it.hasNext()) {
        it.next();
        map.insert(it.key(), it.value());
    }
    return map;
}

int AddKitOperation::execute() const
{
    QVariantMap map = load("Profiles");
    if (map.isEmpty())
        map = initializeKits();

    QVariantMap result = addKit(map, m_id, m_displayName, m_icon, m_debuggerId, m_debuggerEngine,
                                m_debugger, m_deviceType, m_device, m_sysRoot, m_tcs, m_qt,
                                m_mkspec, m_env, m_extra);

    if (result.isEmpty() || map == result)
        return 2;

    return save(result, "Profiles") ? 0 : 3;
}

bool AddToolChainOperation::test() const
{
    QVariantMap map = initializeToolChains();

    // Add toolchain:
    map = addToolChain(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("/tmp/test"),
                            QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
                            KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
    if (map.value(QLatin1String(COUNT)).toInt() != 1
            || !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('0')))
        return false;
    QVariantMap tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('0')).toMap();
    if (tcData.count() != 7
            || tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId")
            || tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name")
            || tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
            || tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
            || tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
            || tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
            || tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
        return false;

    // Ignore same Id:
    QVariantMap unchanged = addToolChain(map, QLatin1String("testId"), QLatin1String("name2"), QLatin1String("/tmp/test2"),
                                              QLatin1String("test-abi2"), QLatin1String("test-abi2,test-abi3"),
                                              KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue2"))));
    if (!unchanged.isEmpty())
        return false;

    // Make sure name stays unique:
    map = addToolChain(map, QLatin1String("testId2"), QLatin1String("name"), QLatin1String("/tmp/test"),
                            QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
                            KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
    if (map.value(QLatin1String(COUNT)).toInt() != 2
            || !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('0'))
            || !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('1')))
        return false;
    tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('0')).toMap();
    if (tcData.count() != 7
            || tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId")
            || tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name")
            || tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
            || tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
            || tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
            || tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
            || tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
        return false;
    tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('1')).toMap();
        if (tcData.count() != 7
                || tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId2")
                || tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name2")
                || tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
                || tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
                || tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
                || tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
                || tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
            return false;

    return true;
}

bool Theme::generate(const QString &path, Theme *theme)
{
    QJsonDocument doc = QkUtils::jsonFromFile(path);

    if(doc.isNull())
        return false;

    QVariantMap themeJson = doc.object().toVariantMap();

    theme->globalStyle = themeJson["globalStyle"].toString();
    theme->editorStyle = themeJson["editorStyle"].toString();
    theme->syntax = themeJson["syntax"].toString();

    QVariantMap paletteJson = themeJson["palette"].toJsonObject().toVariantMap();
    if(!paletteJson.isEmpty())
    {
        theme->globalPalette.setColor(QPalette::Window,     QColor(paletteJson["window"].toString()));
        theme->globalPalette.setColor(QPalette::WindowText, QColor(paletteJson["windowText"].toString()));
        theme->globalPalette.setColor(QPalette::Base, QColor(paletteJson["base"].toString()));
        theme->globalPalette.setColor(QPalette::AlternateBase, QColor(paletteJson["alternateBase"].toString()));
        theme->globalPalette.setColor(QPalette::ToolTipBase, QColor(paletteJson["toolTipBase"].toString()));
        theme->globalPalette.setColor(QPalette::ToolTipText, QColor(paletteJson["toolTipText"].toString()));
        theme->globalPalette.setColor(QPalette::Text, QColor(paletteJson["text"].toString()));
        theme->globalPalette.setColor(QPalette::Button, QColor(paletteJson["button"].toString()));
        theme->globalPalette.setColor(QPalette::ButtonText, QColor(paletteJson["buttonText"].toString()));
    }

    return true;
}

void ResourcesModelPrivate::_q_onRequestFinished() {
    if (!request) {
        return;
    }

    Q_Q(ResourcesModel);

    if (request->status() == ResourcesRequest::Ready) {
        const QVariantMap result = request->result().toMap();
    
        if (!result.isEmpty()) {
            next = result.value("next").toString();
            previous = result.value("previous").toString();
        
            const QVariantList list = result.value("items").toList();
        
            if (!list.isEmpty()) {
                if (roles.isEmpty()) {
                    setRoleNames(list.first().toMap());
                }
                
                q->beginInsertRows(QModelIndex(), items.size(), items.size() + list.size() - 1);
                
                foreach (const QVariant &item, list) {
                    items << item.toMap();
                }
                
                q->endInsertRows();
                emit q->countChanged(q->rowCount());
            }
        }
    }

	foreach(QVariantMap devil, mDevilData)
	{
		if( devil.isEmpty() )
			continue;

		QVariantMap devil_info = cache->devilByID( devil.value("id").toInt() );

		QString lbl = tr("lv%2 %1").arg( devil_info.value("name").toString()
			).arg(devil.value("lvl").toInt() );

		QPixmap icon( QString("icons/devils/icon_%1.png").arg(
			devil_info.value("icon").toString() ) );

		QString tooltip = cache->devilToolTip(devil);

		mDevilLabels.at(i)->setText(lbl);
		mDevilLabels.at(i)->setToolTip(tooltip);
		mDevilIcons.at(i)->setPixmap(icon);
		mDevilIcons.at(i)->setToolTip(tooltip);
		mDevilIcons2.at(i)->setPixmap(icon);
		mDevilIcons2.at(i)->setToolTip(tooltip);

		for(int j = 0; j < max; j++)
		{
			if(j <= i)
				continue;

			if( mDevilData.at(j).isEmpty() )
				continue;

			calculateFusion(i, j);
		}

		i++;
	}

void AppController::processMessageRequest(QList<QByteArray> return_path, QList<QByteArray> payload) {
    QVariantMap response;
    
    QString request = QString::fromUtf8(payload.at(0));
//    qDebug() << "request has" << payload.size() << "packets (expecting 2)";
//    qDebug() << "request verb:" << request;
    
    if(request == "get-devices") {
        response = doGetDevices();
    } else if(request == "get-device" && payload.size() == 2) {
        QString key = payload.at(1);
//        qDebug() << "get-device for key:" << key;
        response = doGetDevice(key);
    } else {
        qDebug() << "request payload not recognized - ignoring";
        return;
    }
    
    MessageHandler* msg_handler = dynamic_cast<MessageHandler*>(sender());
    if(!response.isEmpty() && msg_handler) {
        QList<QByteArray> data;
        data.append(variantMapToJson(response));
//        qDebug() << "sending:" << data;
        msg_handler->sendResponse(return_path, data);
    }
    
}