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);
}