C++ QByteArray::simplified方法代码示例

 void printError()
 {
     QByteArray errorOut = streamProcess.readAllStandardError();
     qDebug() << "Called the C++ slot and got following error:" << errorOut.simplified();
     errorMsg = errorOut.simplified();
     error(errorMsg);
 }

// ------------------------------------------------------------------
bool 
JcnModel::rmvEntry(const QByteArray & s, int itemRow)
{
	if (jcndbg)
		std::cout << "JcnModel::rmvEntry: " << s.simplified().toUpper() << std::endl;

	_entryMap.erase(s.simplified().toUpper());
	takeRow(itemRow);
	return true;
}

void RoomPropertySetter::parseProperty(const QByteArray &command, const Coordinate &roomPos)
{
    QList<QByteArray> words = command.simplified().split(' ');
    AbstractAction *action = 0;
    QByteArray property = words[1];
    uint pos = propPositions[property];
    if (words.size() == 4) {
        //change exit property
        ExitDirection dir = Mmapper2Exit::dirForChar(words[2][0]);
        switch (pos) {
        case E_FLAGS:
        case E_DOORFLAGS:
            action = new ModifyExitFlags(fieldValues[property], dir, pos, FMM_TOGGLE);
            break;
        case E_DOORNAME:
            action = new UpdateExitField(property, dir, pos);
            break;
        default:
            emit sendToUser("unknown property: " + property + "\r\n");
            return;
        }
    } else if (words.size() == 3) {
        //change room property
        switch (pos) {
        case R_TERRAINTYPE:
            action = new UpdatePartial(fieldValues[property], pos);
            break;
        case R_NAME:
        case R_DESC:
            action = new UpdatePartial(property, pos);
            break;
        case R_MOBFLAGS:
        case R_LOADFLAGS:
            action = new ModifyRoomFlags(fieldValues[property], pos, FMM_TOGGLE);
            break;
        case R_DYNAMICDESC:
        case R_NOTE:
            action = new UpdateRoomField(property, pos);
            break;
        case R_PORTABLETYPE:
        case R_LIGHTTYPE:
        case R_ALIGNTYPE:
        case R_RIDABLETYPE:
            action = new UpdateRoomField(fieldValues[property], pos);
            break;
        default:
            emit sendToUser("unknown property: " + property + "\r\n");
            return;
        }

        RoomPropertySetterSlave slave(action);
        emit lookingForRooms(&slave, roomPos);

        if (slave.getResult()) {
            emit sendToUser("OK\r\n");
        } else {
            emit sendToUser("setting " + property + " failed!\r\n");
        }
    }
}

void Tercon::convertData(QByteArray strData){
    TerconData data;
    bool convertIsOK=false;

    strData = strData.simplified();
    QString tempStr = strData;
    int indexSeparator = tempStr.indexOf(QRegExp("[tRU]"));
    QString unitAndNumberData = tempStr.left(indexSeparator+1);
    tempStr.remove(0,indexSeparator+1);
    if(indexSeparator==-1){
        emit message(tr("Ошибка чтения данных Теркона\n"
                        "(разделитель не обнаружен): ")+strData+".",Shared::warning);
        return;
    }

    data.value = tempStr.toDouble(&convertIsOK);
    if (!convertIsOK){
        emit message(tr("Ошибка чтения данных Теркона\n"
                        "(невозможно преобразовать строку в число): ")+strData+".",Shared::warning);
        return;
    }

    data.unit  = unitAndNumberData.at(unitAndNumberData.size()-1);
    unitAndNumberData.chop(1);

    data.channel = unitAndNumberData.toShort(&convertIsOK);
    if (!convertIsOK){
        emit message(tr("Ошибка чтения данных Теркона\n"
                        "(неверный номер канала): ")+strData+".",Shared::warning);
        return;
    }
    data.deviceNumber = deviceNumber;

    emit dataSend(data);
}

void TelemetrySimulator::LogPlaybackController::loadLogFile()
{
  // reset the playback ui
  ui->play->setEnabled(false);
  ui->rewind->setEnabled(false);
  ui->stepBack->setEnabled(false);
  ui->stepForward->setEnabled(false);
  ui->stop->setEnabled(false);
  ui->positionIndicator->setEnabled(false);
  ui->replayRate->setEnabled(false);
  ui->positionLabel->setText("Row #\nTimestamp");

  // clear existing data
  csvRecords.clear();

  QString logFileNameAndPath = QFileDialog::getOpenFileName(NULL, tr("Log File"), ".", tr("LOG Files (*.csv)"));
  QFileInfo fileInfo(logFileNameAndPath);
  QFile file(logFileNameAndPath);
  if (!file.open(QIODevice::ReadOnly)) {
    ui->logFileLabel->setText(tr("ERROR - invalid file"));
    return;
  }
  while (!file.atEnd()) {
    QByteArray line = file.readLine();
    csvRecords.append(line.simplified());
  }
  if (csvRecords.count() > 1) {
    columnNames.clear();
    QStringList keys = csvRecords[0].split(',');
    // override the first two column names
    keys[0] = "LogDate";
    keys[1] = "LogTime";
    Q_FOREACH(QString key, keys) {
      columnNames.append(key.simplified());
    }

void NoSpacesProcessor::processText()
{
    QFile file(m_filename);
    if(!file.open(QIODevice::ReadOnly)) {
        emit error(tr("Could not open file %1").arg(m_filename));
        return;
    }

    const int totalLineCount = detectLineCount();
    int lineNumber(1);

    while(!file.atEnd()) {
        emit progress(lineNumber,totalLineCount,tr("Parsing text with no spaces"));
        QByteArray line = file.readLine();

        emit lineFound(line, lineNumber);

        line = line.simplified();
        if(line.isEmpty()) {
            ++lineNumber;
            continue;
        }

        for(int pos=0;pos<line.count();++pos) {
            emit progress(pos,line.count(),tr("Line %1 of %2").arg(lineNumber).arg(totalLineCount));
            for(int len=1;len<14;++len) {
                emit combinationFound(processorName(),line.mid(pos,len),lineNumber);
            }
        }
        //emit combinationFound(processorName(), word,lineNumber);
        ++lineNumber;
    }
    file.close();

}

/*!
    \internal
    Reads the configuration out from a io device.
*/
void dtkLoggingPrivate::readSettings(QIODevice &device)
{
    QMutexLocker locker(&_mutexRegisteredCategory);
    {
        _logConfigItemList.clear();

        if (device.open(QIODevice::ReadOnly)) {
            QByteArray truearray("true");
            QByteArray line;
            while (!device.atEnd()) {
                line = device.readLine().replace(" ", "");
                line = line.simplified();
                const QList<QByteArray> pair = line.split('=');
                if (pair.count() == 2)
                    _logConfigItemList.append(dtkLogConfigFilterItem(QString::fromLatin1(pair.at(0))
                                                     , (pair.at(1).toLower() == truearray)));
            }
        }

        foreach (dtkLoggingCategory *category, _registeredCategories) {
            updateCategory(category);
        }

        _registerCategories = true;
    }

QByteArray Variant::toUtf8() const
{
  QDomDocument doc;
  xmlWrite(doc, doc);
  QByteArray result = doc.toByteArray(0);
  return result.simplified();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool RiaImageFileCompare::runComparison(QString imgFileName, QString refFileName, QString diffFileName)
{
    reset();

    if (m_compareExecutable.isEmpty())
    {
        m_lastError = SEVERE_ERROR;
        m_errorMsg = "Cannot compare images, no compare executable set";
        return false;
    }


    //QString args = QString("-fuzz 2% -lowlight-color white -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
    // The ImageMagick compare tool on RedHat 5 does not support the lowlight-color options
    // Use GCC version as a crude mechanism for disabling use of this option on RedHat5
#if (__GNUC__ == 4 && __GNUC_MINOR__ <= 1)
    QString args = QString("-fuzz 0.4% -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
#else
    QString args = QString("-fuzz 0.4% -lowlight-color white -metric ae \"%1\" \"%2\" \"%3\"").arg(imgFileName).arg(refFileName).arg((diffFileName));
#endif
    QString completeCommand = QString("\"%1\" %2").arg(m_compareExecutable).arg(args);

    // Launch process and wait
    QProcess proc;
    proc.start(completeCommand);
    proc.waitForFinished(30000);

    QProcess::ProcessError procError = proc.error();
    if (procError != QProcess::UnknownError)
    {
        m_lastError = SEVERE_ERROR;
        m_errorMsg = "Error running compare tool process";
        m_errorDetails = completeCommand;
        return false;
    }

    QByteArray stdErr = proc.readAllStandardError();
    int procExitCode = proc.exitCode();
    if (procExitCode == 0)
    {
        // Strip out whitespace and look for 0 (as in zero pixel differences)
        stdErr = stdErr.simplified();
        if (!stdErr.isEmpty() && stdErr[0] == '0')
        {
            m_imagesEqual = true;
        }

        return true;
    }
    else
    {
        // Report non-severe error
        m_lastError = IC_ERROR;
        m_errorMsg = "Error running compare tool process";
        m_errorDetails = stdErr;

        return false;
    }
}

void
M3uLoader::parseM3u( const QString& fileLink )
{
    QFileInfo fileInfo( fileLink );
    QFile file( QUrl::fromUserInput( fileLink ).toLocalFile() );

    if ( !file.open( QIODevice::ReadOnly | QIODevice::Text ) )
    {
        tDebug() << "Error opening m3u:" << file.errorString();
        return;
    }

    m_title = fileInfo.baseName();
    while ( !file.atEnd() )
    {
         QByteArray line = file.readLine();
         /// If anyone wants to take on the regex for parsing EXT, go ahead
         /// But the notion that users does not tag by a common rule. that seems hard
         /// So ignore that for now
         if ( line.contains( "EXT" ) )
             continue;

         QFileInfo tmpFile( QUrl::fromUserInput( QString( line.simplified() ) ).toLocalFile() );

         if( tmpFile.exists() )
             getTags( tmpFile );
         else
         {
             QUrl fileUrl = QUrl::fromUserInput( QString( QFileInfo(file).canonicalPath() + "/" + line.simplified() ) );
             QFileInfo tmpFile( fileUrl.toLocalFile() );
             if ( tmpFile.exists() )
                getTags( tmpFile );
         }
    }

    if ( m_tracks.isEmpty() )
    {
        tDebug() << Q_FUNC_INFO << "Could not parse M3U!";
        return;
    }

    if ( m_createNewPlaylist )
    {
        m_playlist = Playlist::create( SourceList::instance()->getLocal(),
                                       uuid(),
                                       m_title,
                                       m_info,
                                       m_creator,
                                       false,
                                       m_tracks );

        connect( m_playlist.data(), SIGNAL( revisionLoaded( Tomahawk::PlaylistRevision ) ), this, SLOT( playlistCreated() ) );
    }
    else
        emit tracks( m_tracks );

    m_tracks.clear();
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiaTextFileCompare::runComparison(const QString& baseFolder, const QString& generatedFolder)
{
    reset();

    QString fullFilePath = "diff";
    if (!m_pathToDiffTool.isEmpty())
    {
        fullFilePath = m_pathToDiffTool + "/" + fullFilePath;
    }

    // Command line arguments used when invoking 'diff'
    // See https://docs.freebsd.org/info/diff/diff.info.diff_Options.html
    QString args = "-r -u --strip-trailing-cr";

    QString completeCommand = QString("\"%1\" %2 %3 %4").arg(fullFilePath).arg(baseFolder).arg(generatedFolder).arg(args);

    // Launch process and wait
    QProcess proc;
    proc.start(completeCommand);
    proc.waitForFinished(30000);

    QProcess::ProcessError procError = proc.error();
    if (procError != QProcess::UnknownError)
    {
        m_lastError    = SEVERE_ERROR;
        m_errorMsg     = "Error running 'diff' tool process";
        m_errorDetails = completeCommand;
        return false;
    }

    QByteArray stdErr       = proc.readAllStandardError();
    int        procExitCode = proc.exitCode();

    if (procExitCode == 0)
    {
        return true;
    }
    else if (procExitCode == 1)
    {
        QByteArray stdOut = proc.readAllStandardOutput();
        m_diffOutput      = stdOut;

        return false;
    }
    else
    {
        stdErr = stdErr.simplified();

        // Report non-severe error
        m_lastError    = IC_ERROR;
        m_errorMsg     = "Error running 'diff' tool process";
        m_errorDetails = stdErr;

        return false;
    }
}

/*Checksum of the received packet*/
ANWR_PROTOCOL::RETURN_ANSWER ftdiChip::CheckingReceivedPacket(const QByteArray &bS)
{
if(bS.isEmpty())return ANWR_PROTOCOL::retNoAnsError;
QByteArray cmd = bS.simplified();
if(cmd.contains("#")){
    if(cmd[1]=='>')return ANWR_PROTOCOL::retOK;
    if(cmd[1]=='?')return ANWR_PROTOCOL::retIncorData;
    }
return ANWR_PROTOCOL::retError;
}

int populateAfterRegInfo(QTextStream& t) 
{
	t << endl << endl;
	t << "RESOURCE SERVICE_CONFIGURATION_ARRAY r_service_configuration_reg" << endl;
	t << "\t{" << endl;
	t << "\t\tservice_configuration_array=" << endl;
	t << "\t\t\t{" << endl;

    QFile cf(configurationFile);	

	int err = 0;
	
	QByteArray escapedQuotationMark = QByteArray("\\\"");
	
	if (cf.open(QIODevice::ReadOnly | QIODevice::Text)) {
		QByteArray xmlConf;

		xmlConf = cf.readAll();
		xmlConf = xmlConf.replace("\"","\\\"");
		if (xmlConf.count()) {
			QByteArray xml = xmlConf.simplified();
			for (int n=0;;n++) {
				int splitCount = 255;
				if (xml.size() > 255 && (xml.mid(254, 2) == escapedQuotationMark)) {
					splitCount = 254;
				}
				QByteArray split = xml.left(splitCount);
				if (!split.count()) {
					break;
				}
				if (n) {
					t << "\t\t\t\t,"  << endl;
				}
				t << "\t\t\t\tSERVICE_CONFIGURATION"  << endl;
				t << "\t\t\t\t{" <<  endl;
				t << "\t\t\t\txmldata = \"" << split <<"\";" <<  endl;
				t << "\t\t\t\t}" <<  endl;

				xml = xml.mid(splitCount);
			}
		}	
	} else {
		fprintf(stderr, "Error: Cannot open %s file for reading.", qPrintable(configurationFile));
		err = 1;
	}
	
	t << endl;
	t << "\t\t\t};" << endl;
	t << "\t}" << endl;
	
	return err;
}

void AndroidRunnerWorkerBase::forceStop()
{
    runAdb({"shell", "am", "force-stop", m_androidRunnable.packageName}, 30);

    // try killing it via kill -9
    const QByteArray out = Utils::SynchronousProcess()
            .runBlocking(m_adb, selector() << QStringLiteral("shell") << pidScriptPreNougat)
            .allRawOutput();

    qint64 pid = extractPID(out.simplified(), m_androidRunnable.packageName);
    if (pid != -1) {
        adbKill(pid);
    }
}

MainWindow::MainWindow(QWidget *parent) :
	QMainWindow(parent),
	ui(new Ui::MainWindow)
{
	ui->setupUi(this);

	QByteArray test;

	test.append(49);
	test.append(46);
	test.append(49);
	test.append(56);
	test.append(48);
	test.append(48);
	test.append('\n');
	test.append((char)0);
	test.append(char(0));
	test.append(char(0));
	test.append(char(0));
	test.append(char(0));


	qDebug("org [%s], size %d", test.constData(), test.size());

	QByteArray test3 = test.simplified();

	qDebug("simplified [%s] size %d", test3.constData(), test3.size());


	QByteArray test4 = test.trimmed();

	qDebug("trimmed [%s] size %d", test4.constData(), test4.size());

	float val = test3.toFloat();

	qDebug("value = %f", val);

	if ( test.contains('\n'))

	{
		QByteArray test2 = test.left( test.indexOf('\n'));



		qDebug("%d test2 [%s]", test.indexOf(char(0)), test2.constData());
	}

}