C++ Parser::errorLine方法代码示例

QVariant ContentItemInterfacePrivate::parseReplyDataVariant(const QByteArray &replyData, bool *ok)
{
    QVariant parsed;

#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
    QJson::Parser jsonParser;
    parsed = jsonParser.parse(replyData, ok);
    if (!*ok) {
        qWarning() << Q_FUNC_INFO << "Error parsing JSON file:" << jsonParser.errorString()
                   << "at" << jsonParser.errorLine();
    }
#else
    QJsonParseError jsonError;
    QJsonDocument jsonDocument = QJsonDocument::fromJson(replyData, &jsonError);
    *ok = !jsonDocument.isEmpty();
    if (!*ok) {
        qWarning() << Q_FUNC_INFO << "Error parsing JSON file:" << jsonError.errorString()
                   << "at" << jsonError.offset;
    }
    parsed = jsonDocument.toVariant();
#endif

    if (!*ok) {
        parsed.clear();
    }

    return parsed;
}

void QgsAmsLegendFetcher::handleFinished()
{
  // Parse result
  QJson::Parser parser;
  bool ok = false;
  QVariantMap queryResults = parser.parse( mQueryReply, &ok ).toMap();
  if ( !ok )
  {
    emit error( QString( "Parsing error at line %1: %2" ).arg( parser.errorLine() ).arg( parser.errorString() ) );
  }
  QgsDataSourceURI dataSource( mProvider->dataSourceUri() );
  QList< QPair<QString, QImage> > legendEntries;
  foreach ( const QVariant& result, queryResults["layers"].toList() )
  {
    QVariantMap queryResultMap = result.toMap();
    QString layerId = queryResultMap["layerId"].toString();
    if ( layerId != dataSource.param( "layer" ) && !mProvider->subLayers().contains( layerId ) )
    {
      continue;
    }
    QVariantList legendSymbols = queryResultMap["legend"].toList();
    foreach ( const QVariant& legendEntry, legendSymbols )
    {
      QVariantMap legendEntryMap = legendEntry.toMap();
      QString label = legendEntryMap["label"].toString();
      if ( label.isEmpty() && legendSymbols.size() == 1 )
        label = queryResultMap["layerName"].toString();
      QByteArray imageData = QByteArray::fromBase64( legendEntryMap["imageData"].toByteArray() );
      legendEntries.append( qMakePair( label, QImage::fromData( imageData ) ) );
    }
  }

 QVariant Parse(const QByteArray &data, bool *ok)
 {
     QJson::Parser parser;
     QVariant result = parser.parse(data, ok);
     if (ok != 0 && *ok == false)
         LogError(QString("TundraJson::Parse: Error on line %1: %2")
             .arg(parser.errorLine()).arg(parser.errorString()));
     return result;
 }

void DeclarationValidator::visit(Declaration* declaration)
{
  bool testDataOk;
  QJson::Parser parser;
  QVariantMap testData = parser.parse(preprocess(declaration->comment()), &testDataOk).toMap();
  if (!testDataOk)
  {
    d->testsPassed = false;
    qDebug() << "Error parsing test data for declaration on line" << declaration->range().start.line + 1;
    qDebug() << "Parser error on comment line" << parser.errorLine() << "was" << parser.errorString();
    return;
  }
  if (!KDevelop::runTests(testData, declaration))
    d->testsPassed = false;
}

void polarList::requestFinished(QByteArray res)
{
    QJson::Parser parser;
    bool ok;

    QList<QVariant> result = parser.parse (res, &ok).toList();
    if (!ok) {
        qWarning() << "Error parsing json data " << res;
        qWarning() << "Error: " << parser.errorString() << " (line: " << parser.errorLine() << ")";
    }

    qWarning() << "Polar list: " ;

    foreach (QVariant polar, result)
    {
        qWarning() << "\t-" << polar.toString();
    }

}

 QVariant ParseFile(const QString &filePath, bool removeCommentLines, bool *ok)
 {
     QFile file(filePath);
     if (!file.open(QFile::ReadOnly))
         return QVariant();
     QByteArray data = file.readAll();
     file.close();
     if (removeCommentLines)
     {
         // If we are removing lines, we have to parse here to report correct error line!
         // If this wont be reported right, startup and rendering config errors in console
         // are going to be very confusing to people as the line numbers won't match the file content.
         uint removedLines = 0;
         data = RemoveLines(data, QStringList() << "//" << "#", &removedLines);
         QJson::Parser parser;
         QVariant result = parser.parse(data, ok);
         if (ok != 0 && *ok == false)
             LogError(QString("TundraJson::Parse: Error on line %1: %2")
                 .arg(parser.errorLine()+removedLines).arg(parser.errorString()));
         return result;
     }
     return Parse(data, ok);
 }

    virtual void OnObserve(const char* aTopic, const PRUnichar* aData) {
        // LOGT("aTopic: %s, data: %s", aTopic, NS_ConvertUTF16toUTF8(aData).get());
        QString data((QChar*)aData);
        if (!data.startsWith('{') && !data.startsWith('[') && !data.startsWith('"')) {
            QVariant vdata = QVariant::fromValue(data);
            Q_EMIT q->recvObserve(aTopic, vdata);
            return;
        }
        bool ok = true;
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
        QJson::Parser parser;
        QVariant vdata = parser.parse(data.toUtf8(), &ok);
#else
        QJsonParseError error;
        QJsonDocument doc = QJsonDocument::fromJson(data.toUtf8(), &error);
        ok = error.error == QJsonParseError::NoError;
        QVariant vdata = doc.toVariant();
#endif
        if (ok) {
            // LOGT("mesg:%s, data:%s", aTopic, data.toUtf8().data());
            Q_EMIT q->recvObserve(aTopic, vdata);
        } else {
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
            LOGT("parse: s:'%s', err:%s, errLine:%i", data.toUtf8().data(), parser.errorString().toUtf8().data(), parser.errorLine());
#else
            LOGT("parse: s:'%s', err:%s, errLine:%i", data.toUtf8().data(), error.errorString().toUtf8().data(), error.offset);
#endif
        }
    }

void BdLogic::replyFinished()
{
    QByteArray replyData(m_reply->readAll());

    if(m_replyGotError)
    {
        return;
    }

    qDebug() << BoxNames[m_dlState] << " reply body:\n" << replyData;

    // TODO: if state is login, check if it worked ....

    if(m_dlState != DLSTATE_LOGIN)
    {
        QJson::Parser parser;
        bool parsedOk = true;

        if(m_dlState == DLSTATE_INACTIVEPROJECTS)
        {
            m_boxMapRawJson[BoxNames[m_dlState]] += replyData;
            m_boxMapRawJson[BoxNames[m_dlState]] += "\n";
            m_inactiveProjectListParsedJson.push_back(parser.parse(replyData, &parsedOk));
            m_currentInactiveProjectDlIx++;
        }
        else
        {
            m_boxMapRawJson[BoxNames[m_dlState]] = replyData;
            m_boxMapParsedJson[BoxNames[m_dlState]] = parser.parse(replyData, &parsedOk);

            if(m_dlState == DLSTATE_RESOURCES)
            {
                buildInactiveProjectList();
            }
        }

        if(!parsedOk)
        {
            m_statusString = QString("Error parsing JSON from URL: ");

            if(m_dlState == DLSTATE_RESOURCES)
            {
                m_statusString += DOIT_RESOURCES_DATA_URL;
            }
            else
            {
                m_statusString += DOIT_BASE_DATA_URL;
                m_statusString += BoxNames[m_dlState];
            }
            // User doesn't really need to know line number of error,
            // but print during development:
            qDebug() << m_statusString << ": " << parser.errorString() << ", on line: " << parser.errorLine();

            m_statusCode = BDLOGIC_STATUS_JSON_PARSE_ERROR;

            emit downloadStatusUpdated(m_statusCode, m_statusString);

            m_reply->deleteLater();
            return;
        }

    }

    // After this, I can re-use my QNetworkReply pointer
    m_reply->deleteLater();

    if(m_dlState != DLSTATE_INACTIVEPROJECTS)
    {
        m_dlState++;
    }

    // Catch no inactive projects, as soon as state is entered
    if(m_dlState == DLSTATE_INACTIVEPROJECTS)
    {
        if(m_currentInactiveProjectDlIx >= m_inactiveProjectUUIDList.length())
        {
            m_dlState++;
        }
    }

    if(m_dlState != DLSTATE_FINISHED)
    {
        QNetworkRequest request;
        QString boxUrl;
        if(m_dlState == DLSTATE_RESOURCES)
        {
            boxUrl = DOIT_RESOURCES_DATA_URL;
        }
        else if(m_dlState == DLSTATE_INACTIVEPROJECTS)
        {
            boxUrl = DOIT_BASE_DATA_URL "project/";
            boxUrl += QUrl::toPercentEncoding(m_inactiveProjectUUIDList[m_currentInactiveProjectDlIx]);
        }
        else
        {
            boxUrl = DOIT_BASE_DATA_URL;
            boxUrl += BoxNames[m_dlState];
        }
        request.setUrl(boxUrl);
        m_reply = m_netManager->get(request);
//.........这里部分代码省略.........

bool FEMemoryMetaData::parseMetaData(QString json)
{
	QJson::Parser parser;
	QVariant top = parser.parse(json.toStdString().c_str());
	if (!top.isValid())
	{
		QString errormsg = QString("Error parsing JSON from config file on line number: ") + QString::number(parser.errorLine()) + " error text: " + parser.errorString();
		qDebug() << "Error parsing JSON";
		qDebug() << "Line number:" << parser.errorLine() << "error text:" << parser.errorString();
		qDebug() << "Start Json";
		qDebug() << "Json:" << json;
		qDebug() << "End Json";
		return false;
	}
	QVariantMap topmap = top.toMap();
	QVariantMap errormap = topmap["errormap"].toMap();
	QVariantMap::iterator i = errormap.begin();
	while (i != errormap.end())
	{
		bool ok = false;
		m_errorMap[i.value().toString().mid(2).toInt(&ok,16)] = i.key();
		i++;
	}

	QVariantMap ramvars = topmap["ramvars"].toMap();
	i = ramvars.begin();
	while (i != ramvars.end())
	{
		bool ok = false;
		unsigned short locid = i.key().mid(2).toInt(&ok,16);
		m_readOnlyMetaDataMap[locid] = ReadOnlyRamBlock();
		QVariantMap locidlist = i.value().toMap();
		QString title = locidlist["title"].toString();
		m_readOnlyMetaDataMap[locid].title = title;
		QVariantList locidmap = locidlist["vars"].toList();
		int offset = 0;
		for (int j=0;j<locidmap.size();j++)
		{
			QVariantMap newlocidmap = locidmap[j].toMap();
			ReadOnlyRamData rdata;
			rdata.dataTitle = newlocidmap["name"].toString();
			rdata.dataDescription = newlocidmap["title"].toString();
			rdata.locationId = locid;
			rdata.offset = offset;
			rdata.size = newlocidmap["size"].toInt();
			offset += rdata.size;
			m_readOnlyMetaDataMap[locid].m_ramData.append(rdata);
			m_readOnlyMetaData.append(rdata);
		}
		i++;
	}

	QVariantMap lookups = topmap["lookuptables"].toMap();
	i = lookups.begin();
	while (i != lookups.end())
	{
		QVariantMap lookupmap = i.value().toMap();
		QString keystr = i.key();
		bool ok = false;
		unsigned short keyint = keystr.mid(2).toInt(&ok,16);
		LookupMetaData meta;
		meta.locationid = keyint;
		meta.title = lookupmap["title"].toString();
		if (lookupmap["editable"].toString().toLower() == "true")
		{
			meta.editable = true;
		}
		else
		{
			meta.editable = false;
		}
		m_lookupMetaData[keyint] = meta;
		i++;
	}
	qDebug() << m_readOnlyMetaData.size() << "Ram entries found";
	QVariantMap tables = topmap["tables"].toMap();
	i = tables.begin();
	while (i != tables.end())
	{
		QVariantMap tabledata = i.value().toMap();
		if (tabledata["type"] == "3D")
		{
			Table3DMetaData meta;
			QString id = tabledata["locationid"].toString();
			QString xtitle = tabledata["xtitle"].toString();
			QVariantList xcalc = tabledata["xcalc"].toList();
			QString xdp = tabledata["xdp"].toString();
			unsigned int size = tabledata["size"].toInt();

			QString ytitle = tabledata["ytitle"].toString();
			QVariantList ycalc = tabledata["ycalc"].toList();
			QString ydp = tabledata["ydp"].toString();

			QString ztitle = tabledata["ztitle"].toString();
			QVariantList zcalc = tabledata["zcalc"].toList();
			QString zdp = tabledata["zdp"].toString();

			QString xhighlight = tabledata["xhighlight"].toString();
			QString yhighlight = tabledata["yhighlight"].toString();

//.........这里部分代码省略.........

void
RdioParser::rdioReturned()
{

    QNetworkReply* r = qobject_cast< QNetworkReply* >( sender() );
    Q_ASSERT( r );
    m_reqQueries.remove( r );
    m_count++;
    r->deleteLater();

    if ( r->error() == QNetworkReply::NoError )
    {
        QJson::Parser p;
        bool ok;
        QVariantMap res = p.parse( r, &ok ).toMap();
        QVariantMap result = res.value( "result" ).toMap();

        if ( !ok || result.isEmpty() )
        {
            tLog() << "Failed to parse json from Rdio browse item :" << p.errorString() << "On line" << p.errorLine() << "With data:" << res;

            return;
        }

        QVariantList tracks = result.value( "tracks" ).toList();
        if ( tracks.isEmpty() )
        {
            tLog() << "Got no tracks in result, ignoring!" << result;
            return;
        }

        // Playlists will have these
        m_title = result[ "name" ].toString();
        m_creator = result[ "owner" ].toString();

        foreach( QVariant track, tracks )
        {
            QVariantMap rdioResult = track.toMap();
            QString title, artist, album;

            title = rdioResult.value( "name", QString() ).toString();
            artist = rdioResult.value( "artist", QString() ).toString();
            album = rdioResult.value( "album", QString() ).toString();

            if ( title.isEmpty() && artist.isEmpty() ) // don't have enough...
            {
                tLog() << "Didn't get an artist and track name from Rdio, not enough to build a query on. Aborting" << title << artist << album;
                return;
            }

            Tomahawk::query_ptr q = Tomahawk::Query::get( artist, title, album, uuid(), !m_createPlaylist );
            m_tracks << q;
        }

void
JSPFLoader::gotBody()
{
    QJson::Parser p;
    bool retOk;
    QVariantMap wrapper = p.parse( m_body, &retOk ).toMap();

    if ( !retOk )
    {
        tLog() << "Failed to parse jspf json:" << p.errorString() << "on line" << p.errorLine();
        return;
    }

    if ( !wrapper.contains( "playlist" ) )
    {
        tLog() << "No playlist element in JSPF!";
        return;
    }

    QVariantMap pl = wrapper.value( "playlist" ).toMap();
    QString origTitle = pl.value( "title" ).toString();
    m_info = pl.value( "info" ).toString();
    m_creator = pl.value( "creator" ).toString();

    m_title = origTitle;
    if ( m_title.isEmpty() )
        m_title = tr( "New Playlist" );
    if ( !m_overrideTitle.isEmpty() )
        m_title = m_overrideTitle;

    if ( pl.contains( "track" ) )
    {
        QVariantList tracks = pl.value( "track" ).toList();

        bool shownError = false;
        foreach ( const QVariant& currentTrack, tracks )
        {
            QVariantMap tM = currentTrack.toMap();
            QString artist, album, track, duration, annotation, url;

            artist = tM.value( "creator" ).toString();
            album = tM.value( "album" ).toString();
            track = tM.value( "title" ).toString();
            duration = tM.value( "duration" ).toString();
            annotation = tM.value( "annotation" ).toString();
            if ( tM.value( "location" ).toList().size() > 0 )
                url = tM.value( "location" ).toList().first().toString();

            if ( artist.isEmpty() || track.isEmpty() )
            {
                if ( !shownError )
                {
                    QMessageBox::warning( 0, tr( "Failed to save tracks" ), tr( "Some tracks in the playlist do not contain an artist and a title. They will be ignored." ), QMessageBox::Ok );
                    shownError = true;
                }
                continue;
            }

            track_ptr t = Tomahawk::Track::get( artist, track, album, duration.toInt() / 1000 );
            query_ptr q = Tomahawk::Query::get( t );
            if ( !q )
                continue;

            if ( !url.isEmpty() )
            {
                q->setResultHint( url );
                q->setSaveHTTPResultHint( true );
            }

            m_entries << q;
        }

bool FEMemoryMetaData::parseMetaData(QString json)
{
	QJson::Parser parser;
	QVariant top = parser.parse(json.toStdString().c_str());
	if (!top.isValid())
	{
		QString errormsg = QString("Error parsing JSON from config file on line number: ") + QString::number(parser.errorLine()) + " error text: " + parser.errorString();
		//QMessageBox::information(0,"Error",errormsg);
		qDebug() << "Error parsing JSON";
		qDebug() << "Line number:" << parser.errorLine() << "error text:" << parser.errorString();
		qDebug() << "Start Json";
		qDebug() << "Json:" << json;
		qDebug() << "End Json";
		return false;
	}
	QVariantMap topmap = top.toMap();
	QVariantMap errormap = topmap["errormap"].toMap();
	QVariantMap::iterator i = errormap.begin();
	while (i != errormap.end())
	{
		bool ok = false;
		m_errorMap[i.value().toString().mid(2).toInt(&ok,16)] = i.key();
		i++;
	}

	QVariantMap ramvars = topmap["ramvars"].toMap();
	i = ramvars.begin();
	while (i != ramvars.end())
	{
		bool ok = false;
		unsigned short locid = i.key().mid(2).toInt(&ok,16);
		m_readOnlyMetaDataMap[locid] = ReadOnlyRamBlock();
		QVariantMap locidlist = i.value().toMap();
		QString title = locidlist["title"].toString();
		m_readOnlyMetaDataMap[locid].title = title;
		QVariantList locidmap = locidlist["vars"].toList();
		int offset = 0;
		for (int j=0;j<locidmap.size();j++)
		{
			QVariantMap newlocidmap = locidmap[j].toMap();
			ReadOnlyRamData rdata;
			rdata.dataTitle = newlocidmap["name"].toString();
			rdata.dataDescription = newlocidmap["title"].toString();
			rdata.locationId = locid;
			rdata.offset = offset;
			rdata.size = newlocidmap["size"].toInt();
			offset += rdata.size;
			m_readOnlyMetaDataMap[locid].m_ramData.append(rdata);
			m_readOnlyMetaData.append(rdata);
			//m_readOnlyMetaDataMap[locid].append(rdata);

		}
		/*QVariantMap::iterator j = locidmap.begin();
		while (j != locidmap.end())
		{
			if (j.key() == "title")
			{
				QString title = j.value().toString();
				qDebug() << "Location title:" << title;
			}
			else
			{
				qDebug() << j.key();
				QVariantMap valuemap = j.value().toMap();
				if (valuemap.contains("type"))
				{
					ConfigData cdata;
					cdata.configDescription = valuemap["title"].toString();
					cdata.configTitle = j.key();
					cdata.elementSize = valuemap["size"].toInt();
					cdata.locationId = locid;
					cdata.offset = valuemap["offset"].toInt();
					cdata.type = valuemap["type"].toString();
					QVariantMap calcmap = valuemap["calc"].toMap();
					QList<QPair<QString,double> > calclist;
					QVariantMap::iterator k = calcmap.begin();
					while (k != calcmap.end())
					{
						calclist.append(QPair<QString,double>(k.key(),k.value().toDouble()));
						k++;
					}
					cdata.elementCalc = calclist;
					if (valuemap["type"] == "value")
					{

					}
					else if (valuemap["type"] == "array")
					{
						cdata.arraySize = valuemap["arraysize"].toInt();
					}
					m_configMetaData.append(cdata);
				}

			}
			j++;
		}*/
		i++;
	}
	/*"lookuptables" : {
 "0x8000" : {
//.........这里部分代码省略.........

    virtual void RecvAsyncMessage(const PRUnichar* aMessage, const PRUnichar* aData) {
        NS_ConvertUTF16toUTF8 message(aMessage);
        NS_ConvertUTF16toUTF8 data(aData);

        bool ok = false;
#if (QT_VERSION <= QT_VERSION_CHECK(5, 0, 0))
        QJson::Parser parser;
        QVariant vdata = parser.parse(QByteArray(data.get()), &ok);
#else
        QJsonParseError error;
        QJsonDocument doc = QJsonDocument::fromJson(QByteArray(data.get()), &error);
        ok = error.error == QJsonParseError::NoError;
        QVariant vdata = doc.toVariant();
#endif

        if (!strncmp(message.get(), "embed:", 6) || !strncmp(message.get(), "chrome:", 7)) {
            if (ok) {
                if (!strcmp(message.get(), "embed:alert")) {
                    Q_EMIT q->alert(vdata);
                    return;
                } else if (!strcmp(message.get(), "embed:confirm")) {
                    Q_EMIT q->confirm(vdata);
                    return;
                } else if (!strcmp(message.get(), "embed:prompt")) {
                    Q_EMIT q->prompt(vdata);
                    return;
                } else if (!strcmp(message.get(), "embed:auth")) {
                    Q_EMIT q->authRequired(vdata);
                    return;
                } else if (!strcmp(message.get(), "chrome:title")) {
                    QMap<QString, QVariant> map = vdata.toMap();
                    mTitle = map["title"].toString();
                    Q_EMIT q->titleChanged();
                    return;
                }
            } else {
#if (QT_VERSION <= QT_VERSION_CHECK(5, 0, 0))
                LOGT("parse: err:%s, errLine:%i", parser.errorString().toUtf8().data(), parser.errorLine());
#else
                LOGT("parse: err:%s, errLine:%i", error.errorString().toUtf8().data(), error.offset);
#endif
            }
        }
        LOGT("mesg:%s, data:%s", message.get(), data.get());
        Q_EMIT q->recvAsyncMessage(message.get(), vdata);
    }

void MemoryMetaData::loadMetaDataFromFile(QString filestr)
{


	qDebug() << "Loading config file from:" << filestr;
	QFile file(filestr);
	file.open(QIODevice::ReadOnly);
	QByteArray filebytes = file.readAll();
	file.close();

	QJson::Parser parser;
	QVariant top = parser.parse(filebytes);
	if (!top.isValid())
	{
		QString errormsg = QString("Error parsing JSON from config file on line number: ") + QString::number(parser.errorLine()) + " error text: " + parser.errorString();
		//QMessageBox::information(0,"Error",errormsg);
		qDebug() << "Error parsing JSON";
		qDebug() << "Line number:" << parser.errorLine() << "error text:" << parser.errorString();
		return;
	}
	QVariantMap topmap = top.toMap();
	QVariantMap errormap = topmap["errormap"].toMap();
	QVariantMap::iterator i = errormap.begin();
	while (i != errormap.end())
	{
		bool ok = false;
		m_errorMap[i.value().toString().mid(2).toInt(&ok,16)] = i.key();
		i++;
	}

	QVariantMap ramvars = topmap["ramvars"].toMap();
	i = ramvars.begin();
	while (i != ramvars.end())
	{
		bool ok = false;
		unsigned short locid = i.key().mid(2).toInt(&ok,16);
		m_readOnlyMetaDataMap[locid] = ReadOnlyRamBlock();
		QVariantMap locidlist = i.value().toMap();
		QString title = locidlist["title"].toString();
		m_readOnlyMetaDataMap[locid].title = title;
		QVariantList locidmap = locidlist["vars"].toList();
		int offset = 0;
		for (int j=0;j<locidmap.size();j++)
		{
			QVariantMap newlocidmap = locidmap[j].toMap();
			ReadOnlyRamData rdata;
			rdata.dataTitle = newlocidmap["name"].toString();
			rdata.dataDescription = newlocidmap["title"].toString();
			rdata.locationId = locid;
			rdata.offset = offset;
			rdata.size = newlocidmap["size"].toInt();
			offset += rdata.size;
			m_readOnlyMetaDataMap[locid].m_ramData.append(rdata);
			m_readOnlyMetaData.append(rdata);
			//m_readOnlyMetaDataMap[locid].append(rdata);

		}
		/*QVariantMap::iterator j = locidmap.begin();
		while (j != locidmap.end())
		{
			if (j.key() == "title")
			{
				QString title = j.value().toString();
				qDebug() << "Location title:" << title;
			}
			else
			{
				qDebug() << j.key();
				QVariantMap valuemap = j.value().toMap();
				if (valuemap.contains("type"))
				{
					ConfigData cdata;
					cdata.configDescription = valuemap["title"].toString();
					cdata.configTitle = j.key();
					cdata.elementSize = valuemap["size"].toInt();
					cdata.locationId = locid;
					cdata.offset = valuemap["offset"].toInt();
					cdata.type = valuemap["type"].toString();
					QVariantMap calcmap = valuemap["calc"].toMap();
					QList<QPair<QString,double> > calclist;
					QVariantMap::iterator k = calcmap.begin();
					while (k != calcmap.end())
					{
						calclist.append(QPair<QString,double>(k.key(),k.value().toDouble()));
						k++;
					}
					cdata.elementCalc = calclist;
					if (valuemap["type"] == "value")
					{

					}
					else if (valuemap["type"] == "array")
					{
						cdata.arraySize = valuemap["arraysize"].toInt();
					}
					m_configMetaData.append(cdata);
				}

			}
			j++;
//.........这里部分代码省略.........