void PlatformDomainNameAddressQuery::runBlocking() { //std::cout << "PlatformDomainNameResolver::doRun()" << std::endl; boost::asio::ip::tcp::resolver resolver(ioService); boost::asio::ip::tcp::resolver::query query(hostname, "5222"); try { //std::cout << "PlatformDomainNameResolver::doRun(): Resolving" << std::endl; boost::asio::ip::tcp::resolver::iterator endpointIterator = resolver.resolve(query); //std::cout << "PlatformDomainNameResolver::doRun(): Resolved" << std::endl; if (endpointIterator == boost::asio::ip::tcp::resolver::iterator()) { //std::cout << "PlatformDomainNameResolver::doRun(): Error 1" << std::endl; emitError(); } else { std::vector<HostAddress> results; for ( ; endpointIterator != boost::asio::ip::tcp::resolver::iterator(); ++endpointIterator) { boost::asio::ip::address address = (*endpointIterator).endpoint().address(); results.push_back(address.is_v4() ? HostAddress(&address.to_v4().to_bytes()[0], 4) : HostAddress(&address.to_v6().to_bytes()[0], 16)); } //std::cout << "PlatformDomainNameResolver::doRun(): Success" << std::endl; eventLoop->postEvent( boost::bind(boost::ref(onResult), results, boost::optional<DomainNameResolveError>()), shared_from_this()); } } catch (...) { //std::cout << "PlatformDomainNameResolver::doRun(): Error 2" << std::endl; emitError(); } }
SGMXASScanActionControllerFileWriter::SGMXASScanActionControllerFileWriter(const QString &filePath, bool hasRank2Data, QObject *parent) : QObject(parent) { filePath_ = filePath; hasRank2Data_ = hasRank2Data; QFileInfo rank1FileInfo(filePath+".dat"); if(rank1FileInfo.exists()) emitError(SGMXASScanActionControllerFileWriter::AlreadyExistsError); rank1File_ = new QFile(rank1FileInfo.filePath()); if(!rank1File_->open(QIODevice::WriteOnly | QIODevice::Text)) emitError(SGMXASScanActionControllerFileWriter::CouldNotOpenError); else QTimer::singleShot(0, this, SLOT(emitFileWriterIsBusy())); rank2File_ = 0; //NULL if(hasRank2Data_){ QFileInfo rank2FileInfo(filePath+"_spectra.dat"); if(rank2FileInfo.exists()) emitError(SGMXASScanActionControllerFileWriter::AlreadyExistsError); rank2File_ = new QFile(rank2FileInfo.filePath()); if(!rank2File_->open(QIODevice::WriteOnly | QIODevice::Text)) emitError(SGMXASScanActionControllerFileWriter::CouldNotOpenError); } }
QVariant QPython::getattr(QVariant obj, QString attr) { if (!SINCE_API_VERSION(1, 4)) { emitError(QString("Import PyOtherSide 1.4 or newer to use getattr()")); return QVariant(); } ENSURE_GIL_STATE; PyObjectRef pyobj(convertQVariantToPyObject(obj), true); if (!pyobj) { emitError(QString("Failed to convert %1 to python object: '%1' (%2)").arg(obj.toString()).arg(priv->formatExc())); return QVariant(); } QByteArray byteArray = attr.toUtf8(); const char *attrStr = byteArray.data(); PyObjectRef o(PyObject_GetAttrString(pyobj.borrow(), attrStr), true); if (!o) { emitError(QString("Attribute not found: '%1' (%2)").arg(attr).arg(priv->formatExc())); return QVariant(); } return convertPyObjectToQVariant(o.borrow()); }
// // We need to verify that all of its possible values // (in the enum list) // is distinct and // refer to valid notations if toValidateNotation is set on // void DTDValidator::checkTokenList(const XMLAttDef& curAttDef , bool toValidateNotation) { XMLCh* list = XMLString::replicate(curAttDef.getEnumeration(), getScanner()->getMemoryManager()); ArrayJanitor<XMLCh> janList(list, getScanner()->getMemoryManager()); // // Search forward for a space or a null. If a null, // we are done. If a space, cap it and look it up. // bool breakFlag = false; XMLCh* listPtr = list; XMLCh* lastPtr = listPtr; while (true) { while (*listPtr && (*listPtr != chSpace)) listPtr++; // // If at the end, indicate we need to break after // this one. Else, cap it off here. // if (!*listPtr) breakFlag = true; else *listPtr++ = chNull; //distinction check //there should be no same token found in the remaining list if (XMLString::isInList(lastPtr, listPtr)) { emitError ( XMLValid::AttrDupToken , curAttDef.getFullName() , lastPtr ); } if (toValidateNotation && !fDTDGrammar->getNotationDecl(lastPtr)) { emitError ( XMLValid::UnknownNotRefAttr , curAttDef.getFullName() , lastPtr ); } // Break out if we hit the end last time if (breakFlag) break; // Else move upwards and try again lastPtr = listPtr; } }
void f3_launcher::startCheck(QString devPath) { if (stage != 0) stopCheck(); f3_cui_output.clear(); progress = 0; status = f3_launcher_running; emit f3_launcher_status_changed(f3_launcher_running); this->devPath = devPath; QString command; QStringList args; if (getOption("mode") == "quick") { command = QString(F3_PROBE_COMMAND); if (!probeCommand(command)) { emitError(f3_launcher_no_quick); status = f3_launcher_stopped; emit f3_launcher_status_changed(f3_launcher_stopped); return; } if (getOption("memory") == "minimum") args << QString(F3_OPTION_MIN_MEM); if (getOption("destructive") == "true") args << QString(F3_OPTION_DESTRUCTIVE); args << QString(F3_OPTION_TIME); stage = 11; emit f3_launcher_status_changed(f3_launcher_staged); } else { command = QString(F3_WRITE_COMMAND); stage = 1; if (getOption("cache") == "write") { if (probeDiskFull(devPath) && probeCacheFile(devPath)) { command = QString(F3_READ_COMMAND); stage = 2; } else emitError(f3_launcher_cache_nofound); } if (showProgress) args << QString(F3_OPTION_SHOW_PROGRESS); emit f3_launcher_status_changed(f3_launcher_staged); } args << devPath; f3_cui.start(command, args); if (showProgress) { timer.start(); } }
void TrkDevice::tryTrkRead() { #ifdef Q_OS_WIN const DWORD BUFFERSIZE = 1024; char buffer[BUFFERSIZE]; DWORD charsRead; DWORD totalCharsRead = 0; while (TryReadFile(d->hdevice, buffer, BUFFERSIZE, &charsRead, NULL)) { totalCharsRead += charsRead; d->trkReadBuffer.append(buffer, charsRead); if (isValidTrkResult(d->trkReadBuffer, d->serialFrame)) break; } if (verbose() && totalCharsRead) logMessage("Read" + d->trkReadBuffer.toHex()); if (!totalCharsRead) return; const ushort len = trk::isValidTrkResult(d->trkReadBuffer, d->serialFrame); if (!len) { const QString msg = QString::fromLatin1("Partial message: %1").arg(stringFromArray(d->trkReadBuffer)); emitError(msg); return; } #else const int size = bytesAvailable(d->file.handle()); if (!size) return; const QByteArray data = d->file.read(size); if (verbose()) logMessage("READ " + data.toHex()); d->trkReadBuffer.append(data); const ushort len = trk::isValidTrkResult(d->trkReadBuffer, d->serialFrame); if (!len) { if (d->trkReadBuffer.size() > 10) { const QString msg = QString::fromLatin1("Unable to extract message from '%1' '%2'"). arg(QLatin1String(d->trkReadBuffer.toHex())).arg(QString::fromAscii(d->trkReadBuffer)); emitError(msg); } return; } #endif // Q_OS_WIN trk::TrkResult r; QByteArray rawData; while (extractResult(&d->trkReadBuffer, d->serialFrame, &r, &rawData)) { if (verbose()) logMessage("Read TrkResult " + r.data.toHex()); emit messageReceived(r); if (!rawData.isEmpty()) emit rawDataReceived(rawData); } }
bool ConsoleProcess::start(const QString &program, const QString &args) { if (isRunning()) return false; d->m_errorString.clear(); d->m_error = QProcess::UnknownError; QString pcmd; QString pargs; if (d->m_mode != Run) { // The debugger engines already pre-process the arguments. pcmd = program; pargs = args; } else { QtcProcess::Arguments outArgs; QtcProcess::prepareCommand(program, args, &pcmd, &outArgs, OsTypeWindows, &d->m_environment, &d->m_workingDir); pargs = outArgs.toWindowsArgs(); } const QString err = stubServerListen(); if (!err.isEmpty()) { emitError(QProcess::FailedToStart, msgCommChannelFailed(err)); return false; } QStringList env = d->m_environment.toStringList(); if (!env.isEmpty()) { d->m_tempFile = new QTemporaryFile(); if (!d->m_tempFile->open()) { stubServerShutdown(); emitError(QProcess::FailedToStart, msgCannotCreateTempFile(d->m_tempFile->errorString())); delete d->m_tempFile; d->m_tempFile = 0; return false; } QTextStream out(d->m_tempFile); out.setCodec("UTF-16LE"); out.setGenerateByteOrderMark(false); foreach (const QString &var, fixWinEnvironment(env)) out << var << QChar(0); out << QChar(0); out.flush(); if (out.status() != QTextStream::Ok) { stubServerShutdown(); emitError(QProcess::FailedToStart, msgCannotWriteTempFile()); delete d->m_tempFile; d->m_tempFile = 0; return false; } }
void ItemEditor::close() { // check if file was modified before closing if ( m_modified || fileModified() ) emit fileModified(m_data, m_mime); if (m_editor && m_editor->exitCode() != 0 ) { emitError( tr("editor exit code is %1").arg(m_editor->exitCode()) ); const QByteArray errors = m_editor->readAllStandardError(); if ( !errors.isEmpty() ) emitError( QString::fromUtf8(errors) ); } emit closed(this); }
void AddCollectionTask::doStart(KIMAP::Session *session) { if (parentCollection().remoteId().isEmpty()) { qCWarning(IMAPRESOURCE_LOG) << "Parent collection has no remote id, aborting." << collection().name() << parentCollection().name(); emitError(i18n("Cannot add IMAP folder '%1' for a non-existing parent folder '%2'.", collection().name(), parentCollection().name())); changeProcessed(); return; } const QChar separator = separatorCharacter(); m_pendingJobs = 0; m_session = session; m_collection = collection(); m_collection.setName(m_collection.name().replace(separator, QString())); m_collection.setRemoteId(separator + m_collection.name()); QString newMailBox = mailBoxForCollection(parentCollection()); if (!newMailBox.isEmpty()) { newMailBox += separator; } newMailBox += m_collection.name(); qCDebug(IMAPRESOURCE_LOG) << "New folder: " << newMailBox; KIMAP::CreateJob *job = new KIMAP::CreateJob(session); job->setMailBox(newMailBox); connect(job, &KIMAP::CreateJob::result, this, &AddCollectionTask::onCreateDone); job->start(); }
void Transmitter::sendKeyPacket() { char *out; int keylen = rsa->getPeerPublicKeyLen(); try { if (keylen > 0) { if (blowfish) { int len = rsa->encrypt(blowfish->getPass(), blowfish->getPassLen(), &out); sendSpecialPacket(out, len, DRTA_INFO_NEW_KEY); free(out); } } else { sendResetPacket(); } } catch (Error e) { emitError(e.getText()); } }
void RecognitionControl::run() { Q_ASSERT(recog); RecognitionConfiguration *cfg = setupConfig(); bool success = recog->init(cfg); delete cfg; if (!success) { emitError(i18n("Failed to setup recognition: %1", recog->getLastError())); return; } m_initialized=true; while (shouldBeRunning) { if (!queueLock.tryLock(500)) continue; QString file; if (!toRecognize.isEmpty()) file = toRecognize.dequeue(); queueLock.unlock(); if (file.isNull()) { QThread::msleep(100); } else { emit recognitionResult(file, recog->recognize(file)); emit recognitionDone(file); } } }
bool Expr::parseUnaryExpression() { PARSER_FLOW_TRACER(); /* left associative */ switch (ahead().type()) { case T_AT_SIGN: emitError("addr-of-operator unsupported"); // ### @foo (addr-of operator) return false; case T_MINUS: case T_PLUS: case T_NOT: { Model::ExprUnary::Ptr result = new Model::ExprUnary; result->setUnaryOperator(tokenToUnary(ahead().type())); next(); FAIL_IF_NOT(parsePrimaryExpression()); result->setOperand(model()); setModel(result); return true; } default: return parsePrimaryExpression(); } }
void ListCommand::execute(const QVariantMap options) { DbFilter queryFilter = options.value(OPTION_DB_FILTER).value<DbFilter>(); CommandFileList cmd(getSession()); cmd.setAutoDelete(true); cmd.setFields("items(fileSize,id,title,modifiedDate,createdDate,downloadUrl, headRevisionId)"); QString query = QueryEntry::getEntries(queryFilter); // Keepass db folder is set to root in Google drive if user did not customize it if (config()->get("cloud/GdriveKeepassFolder").toString().length() > 0) cmd.execForFolder(config()->get( "cloud/GdriveKeepassFolder").toString(), query); else cmd.exec(query); cmd.waitForFinish(false); if (cmd.error() == Errors::NO_ERROR) { qRegisterMetaType<GoogleDrive::FileInfoList>("GoogleDrive::FileInfoList"); qRegisterMetaType<GoogleDrive::FileInfo>("GoogleDrive::FileInfo"); GoogleDrive::FileInfoList dbList = cmd.files(); RemoteFileList remoteFileList = RemoteFileImpl::fromGDriveFileInfoList(dbList); setResult(KeePassxDriveSync::ResultBuilder().addValue(remoteFileList).build()); emitSuccess(); } else { emitError(Errors::FileError::LIST_FILES_PROBLEM, QString("Failed to list files for keepass directory")); } }
void QPython::receive(QVariant variant) { QVariantList list = variant.toList(); QString event = list[0].toString(); if (handlers.contains(event)) { QJSValue callback = handlers[event]; QJSValueList args; for (int i=1; i<list.size(); i++) { args << callback.engine()->toScriptValue(list[i]); } QJSValue result = callback.call(args); if (result.isError()) { // Ideally we would throw the error back to Python (so that the // pyotherside.send() method fails, as this is where the call // originated). We can't do this, because the pyotherside.send() // call is asynchronous (it returns before we call into JS), so do // the next best thing and report the error to our error handler in // QML instead. emitError("pyotherside.send() failed handler: " + result.property("fileName").toString() + ":" + result.property("lineNumber").toString() + ": " + result.toString()); } } else { // Default action emit received(variant); } }
void Server::manageError(QString address, int port, QAbstractSocket::SocketError error){ int playerIndex = getPlayerIndex(address, port); if(networkAnswers[playerIndex].isEmpty()){ nbNetworkAnswers++; } else{ qDebug() << "Server::manageError() : SUPER WEIRD, player sent first message " << networkAnswers[playerIndex] << " then error " << error; } switch(waitingForMessage){ case(WAITING_FOR_MESSAGE::INFO): case(WAITING_FOR_MESSAGE::START): emit playerReady(playerIndex, false); break; case(WAITING_FOR_MESSAGE::PLAY): moves[playerIndex] = ""; break; default: break; } if(nbNetworkAnswers == addresses.size()){ handleTransition(); } emit emitError(playerIndex, error); }
void QPython::addImportPath(QString path) { ENSURE_GIL_STATE; // Strip leading "file://" (for use with Qt.resolvedUrl()) if (path.startsWith("file://")) { #ifdef WIN32 // On Windows, path would be "file:///C:\...", so strip 8 chars to get // a Windows-compatible absolute filename to be used as import path path = path.mid(8); #else path = path.mid(7); #endif } if (SINCE_API_VERSION(1, 3) && path.startsWith("qrc:")) { const char *module = "pyotherside.qrc_importer"; QString filename = "/io/thp/pyotherside/qrc_importer.py"; QString errorMessage = priv->importFromQRC(module, filename); if (!errorMessage.isNull()) { emitError(errorMessage); } } QByteArray utf8bytes = path.toUtf8(); PyObject *sys_path = PySys_GetObject((char*)"path"); PyObjectRef cwd(PyUnicode_FromString(utf8bytes.constData()), true); PyList_Insert(sys_path, 0, cwd.borrow()); }
// MEMBER FUNCTION int Trick::MemoryManager::ref_assignment( REF2* R, V_TREE* V) { int ret = 0; UCFn *cf = NULL; // Create a units conversion function if necessary. if (R->units) { try { Unit *from_units = new Unit(R->units); Unit *to_units = new Unit(R->attr->units); // This Conversion_to call allocates a new UCFn cf = from_units->Conversion_to( to_units); delete from_units; delete to_units; } catch (Unit::CONVERSION_ERROR) { std::stringstream message; message << "Can't convert \"" << R->units << "\" to \"" << R->attr->units << "\"."; emitError(message.str()); cf = NULL; return TRICK_UNITS_CONVERSION_ERROR ; } } // R->num_index is badly named. It is really the current dimension ret = assign_recursive( R->address, R->attr, R->num_index, 0, V, cf); delete cf ; return ( ret); }
// MEMBER FUNCTION void Trick::MemoryManager::clear_var( void* address) { ATTRIBUTES* reference_attr; ALLOC_INFO* alloc_info; pthread_mutex_lock(&mm_mutex); alloc_info = get_alloc_info_at( address); if (alloc_info != NULL) { reference_attr = make_reference_attr( alloc_info); if (alloc_info->type == TRICK_STRUCTURED ) { if (alloc_info->num_index != 0) { clear_arrayed_class( (char*)(alloc_info->start), reference_attr, 0, 0) ; } else { clear_class( (char*)(alloc_info->start), alloc_info->attr) ; } } else { clear_rvalue( alloc_info->start, reference_attr, 0, 0 ); } free_reference_attr( reference_attr); } else { std::stringstream message; message << "Cannot clear the variable at address " << address << "because memory manager knows nothing about it." ; emitError(message.str()); } pthread_mutex_unlock(&mm_mutex); }
bool createImportDir(const KUrl url) { Q_ASSERT(url.isLocalFile()); // FIXME: Support remote urls if (!KStandardDirs::makeDir(url.toLocalFile())) { emitError(i18n("Could not create destination folder.")); return false; } QString message; mTempImportDir = FileUtils::createTempDir(url.toLocalFile(), ".gwenview_importer-", &message); if (mTempImportDir.isEmpty()) { emitError(i18n("Could not create temporary upload folder:\n%1", message)); return false; } return true; }
AMContinuousScanActionControllerAMDSClientDataRequestFileWriter::AMContinuousScanActionControllerAMDSClientDataRequestFileWriter(const QString &filePath, QObject *parent) : QObject(parent) { filePath_ = filePath; QFileInfo clientDataRequestFileInfo(filePath+".cdr"); if(clientDataRequestFileInfo.exists()) emitError(AMScanActionControllerBasicFileWriter::AlreadyExistsError); clientDataRequestFile_ = new QFile(clientDataRequestFileInfo.filePath()); if(!clientDataRequestFile_->open(QIODevice::WriteOnly)) emitError(AMScanActionControllerBasicFileWriter::CouldNotOpenError); else QTimer::singleShot(0, this, SLOT(emitFileWriterIsBusy())); }
void AuthorizedCommand::refreshTokenFinished() { CommandRefreshToken* cmd = qobject_cast<CommandRefreshToken*>(sender()); if (cmd->error() == NoError) reexecuteQuery(); else emitError(AuthorizationNeeded, cmd->errorString()); }
void HttpDownloadWorker::doWork() { if(!mapFile2Memory()) //Ó³ÉäÎļþµ½ÄÚ´æ { emitError(error()); return; } downloadSmallPiece(); }
bool SQLCache::childMailboxesFresh(const QString &mailbox) const { queryChildMailboxesFresh.bindValue(0, mailboxName(mailbox)); if (! queryChildMailboxesFresh.exec()) { emitError(QObject::tr("Query queryChildMailboxesFresh failed"), queryChildMailboxesFresh); return false; } return queryChildMailboxesFresh.first(); }
bool Expr::parsePrimaryExpression() { PARSER_FLOW_TRACER(); switch(ahead().type()) { case T_LEFT_PAREN: { REQUIRE_TOKEN(T_LEFT_PAREN); FAIL_IF_NOT(parseExpression()); REQUIRE_TOKEN(T_RIGHT_PAREN); return true; } case T__NUMBER: { next(); setModel(new Model::ExprConstNumber(current().number())); return true; } case T__STRING: { next(); setModel(new Model::ExprConstString(QString::fromUtf8(current().text().constData()))); return true; } case T__FLOAT: next(); setModel(new Model::ExprConstDouble(current().numberFloat())); return true; case T__IDENTIFIER: { Model::Decl::Ptr decl = curCtx()->lookup(ahead().identifier()); if (!decl) { emitError(QLatin1Literal("Unknown identifier: ") % Model::Identifier(ahead().identifier()).toString()); return false; } if (decl->type() == Model::oDeclConst) { next(); Model::ExprConstConst::Ptr ecc = new Model::ExprConstConst; ecc->setDecl(decl.scast<Model::DeclConst>()); setModel(ecc); return true; } LValue lvp(this); lvp.setOptions(LValue::AllowFunctionCall); FAIL_IF_NOT(lvp()); Model::ExprLValue::Ptr elv = new Model::ExprLValue; elv->setLValue(lvp.model()); setModel(elv); return true; } default: return false; } }
DallasError DeviceDS18B20::readConfiguration() { QMutexLocker locker(busMutex); DallasError error = ds18b20GetResolution(&id, &m_resolution); if (error != DALLAS_NO_ERROR) { QString message(dallasGetErrorText(error)); emitError(message); } return error; }
DallasError DeviceDS18B20::writeConfiguration() { QMutexLocker locker(busMutex); DallasError error = ds18b20Setup(&id, m_resolution, DS18B20_NO_ALARM_LOW, DS18B20_NO_ALARM_HIGH); if (error != DALLAS_NO_ERROR) { QString message(dallasGetErrorText(error)); emitError(message); } return error; }
// MEMBER FUNCTION void* Trick::MemoryManager:: declare_extern_var( void* address, const char* element_definition, int n_elems) { void* res_address = NULL; int cdims[8]; int n_cdims; ADefParseContext* context = NULL; std::stringstream alloc_decl_sstream; /** We know that our array will be at least one dimensional and that dimension contains n_elems elements. */ cdims[0] = n_elems; n_cdims = 1; alloc_decl_sstream << element_definition; /** @li Create a parse context. */ context = new ADefParseContext( &alloc_decl_sstream); if (context != NULL) { /** @li Parse the allocation definition and ensure that the dimension is at least one less than the maximum of 8. */ if (( ADEF_parse( context) == 0) && (context->n_cdims < 8) ){ int ii; /** @li Add the dimensions of the element definition. */ for (ii=0 ; ii < context->n_cdims ; ii++) { cdims[ii+1] = context->cdims[ii]; n_cdims ++; } /** @li Call the general form of declare_var to perform the allocation. */ res_address = declare_extern_var( address, context->type, context->user_type_name, context->n_stars, context->var_name, n_cdims, cdims); /** @li Delete the parse context. */ delete( context); } else { std::stringstream message; message << "declare_extern_var( \"" << element_definition << "\"," << n_elems << ") failed."; emitError(message.str()); } } /** @li Return the address of the allocation. */ return ( res_address); }
bool TrkWriteQueueDevice::trkWriteRawMessage(const TrkMessage &msg) { const QByteArray ba = trk::frameMessage(msg.code, msg.token, msg.data, serialFrame()); if (verbose()) logMessage("WRITE: " + trk::stringFromArray(ba)); QString errorMessage; const bool rc = write(ba, &errorMessage); if (!rc) emitError(errorMessage); return rc; }
f3_launcher::f3_launcher() { errCode = f3_launcher_ok; float version = probeVersion(); if (version == 0) { emitError(f3_launcher_no_cui); return; } if (version < 4.0 || !probeCommand(F3_PROBE_COMMAND)) { emitError(f3_launcher_no_quick); } if (version <= 6.0) { emitError(f3_launcher_no_progress); showProgress = false; } else { emit f3_launcher_status_changed(f3_launcher_ready); showProgress = true; } options["mode"] = "legacy"; options["cache"] = "none"; options["memory"] = "full"; options["destructive"] = "no"; stage = 0; connect(&f3_cui, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(on_f3_cui_finished())); connect(&timer, SIGNAL(timeout()), this, SLOT(on_timer_timeout())); timer.setInterval(1500); }
// =========================================================================== // method definitions // =========================================================================== PositionVector GeomConvHelper::parseShapeReporting(const std::string& shpdef, const std::string& objecttype, const char* objectid, bool& ok, bool allowEmpty, bool report) { if (shpdef == "") { if (!allowEmpty) { emitError(report, "Shape", objecttype, objectid, "the shape is empty"); ok = false; } return PositionVector(); } StringTokenizer st(shpdef, " "); PositionVector shape; while (st.hasNext()) { StringTokenizer pos(st.next(), ","); if (pos.size() != 2 && pos.size() != 3) { emitError(report, "Shape", objecttype, objectid, "the position is neither x,y nor x,y,z"); ok = false; return PositionVector(); } try { SUMOReal x = TplConvert::_2SUMOReal(pos.next().c_str()); SUMOReal y = TplConvert::_2SUMOReal(pos.next().c_str()); if (pos.size() == 2) { shape.push_back(Position(x, y)); } else { SUMOReal z = TplConvert::_2SUMOReal(pos.next().c_str()); shape.push_back(Position(x, y, z)); } } catch (NumberFormatException&) { emitError(report, "Shape", objecttype, objectid, "not numeric position entry"); ok = false; return PositionVector(); } catch (EmptyData&) { emitError(report, "Shape", objecttype, objectid, "empty position entry"); ok = false; return PositionVector(); } } return shape; }