int onHeadersComplete(http_parser *parser) { TcpSocket *socket = static_cast<TcpSocket*>(parser->data); #ifndef NO_LOG sLog(LogEndpoint::LogLevel::DEBUG) << " === parsed header ===="; const QHash<QString, QSharedPointer<QString>> &headers = socket->getHeader().getHeaderInfo(); QHash<QString, QSharedPointer<QString>>::const_iterator i = headers.constBegin(); while (i != headers.constEnd()) { sLog(LogEndpoint::LogLevel::DEBUG) << i.key() << *(i.value().data()); ++i; } sLog(LogEndpoint::LogLevel::DEBUG) << " === ============= ===="; sLogFlush(); #endif QWeakPointer<QString> host = socket->getHeader().getHeaderInfo("Host"); if (!host.isNull()) { socket->getHeader().setHost(*host.data()); } return 0; }
// The access function for guarded QObject pointers. static void *qpointer_access_func(sipSimpleWrapper *w, AccessFuncOp op) { #if QT_VERSION >= 0x040500 QWeakPointer<QObject> *guard = reinterpret_cast<QWeakPointer<QObject> *>(w->data); #else QObjectGuard *guard = reinterpret_cast<QObjectGuard *>(w->data); #endif void *addr; switch (op) { case UnguardedPointer: #if QT_VERSION >= 0x040500 addr = guard->data(); #else addr = guard->unguarded; #endif break; case GuardedPointer: #if QT_VERSION >= 0x040500 addr = guard->isNull() ? 0 : guard->data(); #else addr = (QObject *)guard->guarded; #endif break; case ReleaseGuard: delete guard; addr = 0; break; } return addr; }
void MetaQueryWidget::populateComboBox( QStringList results ) { QObject* query = sender(); if( !query ) return; QWeakPointer<KComboBox> combo = m_runningQueries.value(query); if( combo.isNull() ) return; // note: adding items seems to reset the edit text, so we have // to take care of that. disconnect( combo.data(), 0, this, 0 ); // want the results unique and sorted const QSet<QString> dataSet = results.toSet(); QStringList dataList = dataSet.toList(); dataList.sort(); combo.data()->addItems( dataList ); KCompletion* comp = combo.data()->completionObject(); comp->setItems( dataList ); // reset the text and re-enable the signal combo.data()->setEditText( m_filter.value ); connect( combo.data(), SIGNAL(editTextChanged( const QString& ) ), SLOT(valueChanged(const QString&)) ); }
QNetworkAccessManager* nam() { if ( s_nam.isNull() ) return 0; return s_nam.data(); }
void tst_QSharedPointer::downCast() { { QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData); QSharedPointer<Data> baseptr = qSharedPointerCast<Data>(ptr); QSharedPointer<Data> other; QVERIFY(ptr == baseptr); QVERIFY(baseptr == ptr); QVERIFY(! (ptr != baseptr)); QVERIFY(! (baseptr != ptr)); QVERIFY(ptr != other); QVERIFY(other != ptr); QVERIFY(! (ptr == other)); QVERIFY(! (other == ptr)); } { QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData); QSharedPointer<Data> baseptr = ptr; } int destructorCount; destructorCount = DerivedData::derivedDestructorCounter; { QSharedPointer<Data> baseptr; { QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData); baseptr = ptr; QVERIFY(baseptr == ptr); } } QCOMPARE(DerivedData::derivedDestructorCounter, destructorCount + 1); destructorCount = DerivedData::derivedDestructorCounter; { QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData); QWeakPointer<Data> baseptr = ptr; QVERIFY(baseptr == ptr); ptr = QSharedPointer<DerivedData>(); QVERIFY(baseptr.isNull()); } QCOMPARE(DerivedData::derivedDestructorCounter, destructorCount + 1); destructorCount = DerivedData::derivedDestructorCounter; { QSharedPointer<DerivedData> ptr = QSharedPointer<DerivedData>(new DerivedData); QWeakPointer<DerivedData> weakptr(ptr); QSharedPointer<Data> baseptr = weakptr; QVERIFY(baseptr == ptr); QWeakPointer<Data> baseweakptr = weakptr; QVERIFY(baseweakptr == ptr); } QCOMPARE(DerivedData::derivedDestructorCounter, destructorCount + 1); }
//static void DrKonqi::saveReport(const QString & reportText, QWidget *parent) { if (KCmdLineArgs::parsedArgs()->isSet("safer")) { KTemporaryFile tf; tf.setSuffix(".kcrash.txt"); tf.setAutoRemove(false); if (tf.open()) { QTextStream textStream(&tf); textStream << reportText; textStream.flush(); KMessageBox::information(parent, i18nc("@info", "Report saved to <filename>%1</filename>.", tf.fileName())); } else { KMessageBox::sorry(parent, i18nc("@info","Could not create a file in which to save the report.")); } } else { QString defname = getSuggestedKCrashFilename(crashedApplication()); QWeakPointer<KFileDialog> dlg = new KFileDialog(defname, QString(), parent); dlg.data()->setSelection(defname); dlg.data()->setCaption(i18nc("@title:window","Select Filename")); dlg.data()->setOperationMode(KFileDialog::Saving); dlg.data()->setMode(KFile::File); dlg.data()->setConfirmOverwrite(true); dlg.data()->exec(); if (dlg.isNull()) { //Dialog is invalid, it was probably deleted (ex. via DBus call) //return and do not crash return; } KUrl fileUrl = dlg.data()->selectedUrl(); delete dlg.data(); if (fileUrl.isValid()) { KTemporaryFile tf; if (tf.open()) { QTextStream ts(&tf); ts << reportText; ts.flush(); } else { KMessageBox::sorry(parent, i18nc("@info","Cannot open file <filename>%1</filename> " "for writing.", tf.fileName())); return; } if (!KIO::NetAccess::upload(tf.fileName(), fileUrl, parent)) { KMessageBox::sorry(parent, KIO::NetAccess::lastErrorString()); } } } }
void Ut_MApplicationPage::testCustomNavigationBarContentOwnershipOnPageDeletion() { QGraphicsWidget *customNavigationBarContent = new QGraphicsWidget; QWeakPointer<QGraphicsWidget> customNavigationBarContentPointer = customNavigationBarContent; m_subject->setCustomNavigationBarContent(customNavigationBarContent); delete m_subject; m_subject = 0; QVERIFY(customNavigationBarContentPointer.isNull()); }
int PasswordDialog::exec() { Q_D(PasswordDialog); if (d->eventLoop) // recursive call return -1; QEventLoop eventLoop; d->eventLoop = &eventLoop; QWeakPointer<PasswordDialog> guard = this; (void) eventLoop.exec(); d->eventLoop = 0; if (guard.isNull()) return PasswordDialog::Rejected; return result(); }
void SimplePersonSetTest::testConstructorDestructorCreate() { // Create a PersonSet. SimplePersonSetPtr personSet = SimplePersonSet::create(); QVERIFY(!personSet.isNull()); // Get a QWeakPointer to it, for testing destruction. QWeakPointer<PersonSet> weakPtr = QWeakPointer<PersonSet>(personSet.data()); // Remove the only strong ref. personSet.reset(); // Check the PersonSet was deleted OK QVERIFY(personSet.isNull()); QVERIFY(weakPtr.isNull()); }
void Ut_MApplicationPage::testCustomNavigationBarContentSetterAndGetter() { QGraphicsWidget *customNavigationBarContent = new QGraphicsWidget; QWeakPointer<QGraphicsWidget> customNavigationBarContentPointer = customNavigationBarContent; QVERIFY(m_subject->customNavigationBarContent() == 0); m_subject->setCustomNavigationBarContent(customNavigationBarContent); QVERIFY(m_subject->customNavigationBarContent() == customNavigationBarContent); m_subject->setCustomNavigationBarContent(0); QVERIFY(m_subject->customNavigationBarContent() == 0); // Page should have deleted the old widget when replacing it with the 0 (null) one. QVERIFY(customNavigationBarContentPointer.isNull()); }
void myMessageOutput(QtMsgType type, const char *msg) { QString strMsg = QString::fromLatin1(msg); if (!QCoreApplication::closingDown()) { if (!logger.isNull()) { if (recursiveLock.testAndSetOrdered(0, 1)) { QMetaObject::invokeMethod(logger.data(), "append", Q_ARG(QString, strMsg)); recursiveLock = 0; } } else { warnings += strMsg; warnings += QLatin1Char('\n'); } } if (systemMsgOutput) { // Windows systemMsgOutput(type, msg); } else { // Unix fprintf(stderr, "%s\n", msg); fflush(stderr); } }
//public slot void ProblemModelAdapter::setProblem(QWeakPointer<PlanningProblem> problem) { /* We have to do this with the start and end markers to prevent and annoying save/load bug where the markers disappear and reappear upong loading over and over */ if (!_startMarker.isNull()) { disconnect(_startMarker.data(), SIGNAL(destroyed()), this, SLOT(handleStartMarkerDestroyed())); _startMarker->deleteLater(); _startMarker = 0; } _problem = problem; if (problem.isNull()) return; _objectToArea.clear(); PlanningProblem * raw = problem.data(); connect(raw, SIGNAL(startPositionChanged(Position)), this, SLOT(handleStartPositionChanged(Position))); connect(raw, SIGNAL(startPositionRemoved()), this, SLOT(handleStartPositionRemoved())); connect(raw, SIGNAL(areaAdded(QSharedPointer<TaskArea>)), this, SLOT(handleAreaAdded(QSharedPointer<TaskArea>))); }
// The access function for guarded QObject pointers. static void *qpointer_access_func(sipSimpleWrapper *w, AccessFuncOp op) { QWeakPointer<QObject> *guard = reinterpret_cast<QWeakPointer<QObject> *>(w->data); void *addr; switch (op) { case UnguardedPointer: addr = guard->data(); break; case GuardedPointer: addr = guard->isNull() ? 0 : guard->data(); break; case ReleaseGuard: delete guard; addr = 0; break; } return addr; }
void myMessageOutput(QtMsgType type, const char *msg) { QString strMsg = QString::fromLatin1(msg); if (!QCoreApplication::closingDown()) { if (!logger.isNull()) { if (recursiveLock.testAndSetOrdered(0, 1)) { QMetaObject::invokeMethod(logger.data(), "append", Q_ARG(QString, strMsg)); recursiveLock = 0; } } else { warnings += strMsg; warnings += QLatin1Char('\n'); } } #if defined (Q_OS_SYMBIAN) static int fd = -1; if (fd == -1) fd = ::open("E:\\qml.log", O_WRONLY | O_CREAT); ::write(fd, msg, strlen(msg)); ::write(fd, "\n", 1); ::fsync(fd); switch (type) { case QtFatalMsg: abort(); } #endif if (systemMsgOutput) { systemMsgOutput(type, msg); } else { // Unix fprintf(stderr, "%s\n", msg); fflush(stderr); } }
void JabberEditAccountWidget::removeAccount() { QWeakPointer<QMessageBox> messageBox = new QMessageBox(this); messageBox.data()->setWindowTitle(tr("Confirm account removal")); messageBox.data()->setText(tr("Are you sure you want to remove account %1 (%2)?") .arg(account().accountIdentity().name()) .arg(account().id())); QPushButton *removeButton = messageBox.data()->addButton(tr("Remove account"), QMessageBox::AcceptRole); messageBox.data()->addButton(QMessageBox::Cancel); messageBox.data()->setDefaultButton(QMessageBox::Cancel); messageBox.data()->exec(); if (messageBox.isNull()) return; if (messageBox.data()->clickedButton() == removeButton) { AccountManager::instance()->removeAccountAndBuddies(account()); deleteLater(); } delete messageBox.data(); }
void InternalCoreConnection::onNewMessage(Common::MessageHeader::MessageType type, const google::protobuf::Message& message) { // While we are not authenticated we accept only two message types. if (!this->authenticated && type != Common::MessageHeader::GUI_ASK_FOR_AUTHENTICATION && type != Common::MessageHeader::GUI_AUTHENTICATION_RESULT) return; switch (type) { case Common::MessageHeader::GUI_ASK_FOR_AUTHENTICATION: { const Protos::GUI::AskForAuthentication& askForAuthentication = static_cast<const Protos::GUI::AskForAuthentication&>(message); Protos::GUI::Authentication authentication; this->salt = askForAuthentication.salt(); if (!this->password.isEmpty()) this->connectionInfo.password = Common::Hasher::hashWithSalt(this->password, this->salt); authentication.mutable_password_challenge()->set_hash(Common::Hasher::hashWithSalt(this->connectionInfo.password, askForAuthentication.salt_challenge()).getData(), Common::Hash::HASH_SIZE); this->password.clear(); this->send(Common::MessageHeader::GUI_AUTHENTICATION, authentication); } break; case Common::MessageHeader::GUI_AUTHENTICATION_RESULT: { const Protos::GUI::AuthenticationResult& authenticationResult = static_cast<const Protos::GUI::AuthenticationResult&>(message); if (authenticationResult.status() == Protos::GUI::AuthenticationResult::AUTH_OK) { this->connectedAndAuthenticated(); } else { switch (authenticationResult.status()) { case Protos::GUI::AuthenticationResult::AUTH_PASSWORD_NOT_DEFINED: emit connectingError(ICoreConnection::ERROR_NO_REMOTE_PASSWORD_DEFINED); break; case Protos::GUI::AuthenticationResult::AUTH_BAD_PASSWORD: emit connectingError(ICoreConnection::ERROR_WRONG_PASSWORD); break; case Protos::GUI::AuthenticationResult::AUTH_ERROR: emit connectingError(ICoreConnection::ERROR_UNKNOWN); break; default:; } } } break; case Common::MessageHeader::GUI_STATE: { const Protos::GUI::State& state = static_cast<const Protos::GUI::State&>(message); emit newState(state); this->send(Common::MessageHeader::GUI_STATE_RESULT); } break; case Common::MessageHeader::GUI_EVENT_CHAT_MESSAGES: { const Protos::GUI::EventChatMessages& eventChatMessages = static_cast<const Protos::GUI::EventChatMessages&>(message); if (eventChatMessages.message_size() > 0) emit newChatMessages(eventChatMessages); } break; case Common::MessageHeader::GUI_EVENT_LOG_MESSAGE: { const Protos::GUI::EventLogMessage& eventLogMessage = static_cast<const Protos::GUI::EventLogMessage&>(message); QDateTime dateTime = QDateTime::fromMSecsSinceEpoch(eventLogMessage.time()); QString message = Common::ProtoHelper::getStr(eventLogMessage, &Protos::GUI::EventLogMessage::message); LM::Severity severity = LM::Severity(eventLogMessage.severity()); emit newLogMessage(LM::Builder::newEntry(dateTime, severity, message)); } break; case Common::MessageHeader::GUI_SEARCH_TAG: { const Protos::GUI::Tag& tagMessage = static_cast<const Protos::GUI::Tag&>(message); while (!this->searchResultsWithoutTag.isEmpty()) { QWeakPointer<SearchResult> searchResult = this->searchResultsWithoutTag.takeFirst(); if (!searchResult.isNull()) { searchResult.data()->setTag(tagMessage.tag()); break; } } } break; case Common::MessageHeader::GUI_SEARCH_RESULT: { const Protos::Common::FindResult& findResultMessage = static_cast<const Protos::Common::FindResult&>(message); emit searchResult(findResultMessage); } break; case Common::MessageHeader::GUI_BROWSE_TAG: { const Protos::GUI::Tag& tagMessage = static_cast<const Protos::GUI::Tag&>(message); while (!this->browseResultsWithoutTag.isEmpty()) { QWeakPointer<BrowseResult> browseResult = this->browseResultsWithoutTag.takeFirst(); if (!browseResult.isNull()) { browseResult.data()->setTag(tagMessage.tag()); break; } } } break; case Common::MessageHeader::GUI_BROWSE_RESULT: { const Protos::GUI::BrowseResult& browseResultMessage = static_cast<const Protos::GUI::BrowseResult&>(message); emit browseResult(browseResultMessage); } break; default:; } }
void tst_QSharedPointer::memoryManagement() { int generation = Data::generationCounter + 1; int destructorCounter = Data::destructorCounter; QSharedPointer<Data> ptr = QSharedPointer<Data>(new Data); QCOMPARE(ptr->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); ptr = ptr; QCOMPARE(ptr->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); { QSharedPointer<Data> copy = ptr; QCOMPARE(ptr->generation, generation); QCOMPARE(copy->generation, generation); // copy goes out of scope, ptr continues } QCOMPARE(ptr->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); { QWeakPointer<Data> weak = ptr; weak = ptr; QCOMPARE(ptr->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); weak = weak; QCOMPARE(ptr->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); QSharedPointer<Data> strong = weak; QCOMPARE(ptr->generation, generation); QCOMPARE(strong->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); // both weak and strong go out of scope } QCOMPARE(ptr->generation, generation); QCOMPARE(Data::destructorCounter, destructorCounter); QCOMPARE(Data::generationCounter, generation); QWeakPointer<Data> weak = ptr; ptr = QSharedPointer<Data>(); // destructor must have been called QCOMPARE(Data::destructorCounter, destructorCounter + 1); QVERIFY(ptr.isNull()); QVERIFY(weak.isNull()); // if we create a strong pointer from the weak, it must still be null ptr = weak; QVERIFY(ptr.isNull()); QVERIFY(ptr == 0); QCOMPARE(ptr.data(), (Data*)0); }