FCL/sf/mw/qtextensions: comparison qtmobility/src/contacts/qcontactmanagerengine.cpp

equal deleted inserted replaced

-:06b8e2af4411
+:6fbed849b4f4
 #include "qcontactfetchhint.h"
 #include "qcontact_p.h"
 #include "qcontactdetail_p.h"
+#include <QMutex>
+#include <QMutexLocker>
+#include <QWeakPointer>
 QTM_BEGIN_NAMESPACE
 /*!
 \class QContactManagerEngine
 \brief The QContactManagerEngine class provides the interface for all
 Saves the given \a relationships in the database and returns true if the operation was successful.
 For any relationship which was unable to be saved, an entry into the \a errorMap will be created,
 with the key being the index into the input relationships list, and the value being the error which
 occurred for that index.
+The supplied \a errorMap parameter may be null, if the client does not desire detailed error information.
+If supplied, it will be empty upon entry to this function.
 The overall operation error will be saved in \a error.
 */
 bool QContactManagerEngine::saveRelationships(QList<QContactRelationship>* relationships, QMap<int, QContactManager::Error>* errorMap, QContactManager::Error* error)
 {
 Q_UNUSED(relationships);
 /*!
 Removes the given \a relationships from the database and returns true if the operation was successful.
 For any relationship which was unable to be removed, an entry into the \a errorMap will be created,
 with the key being the index into the input relationships list, and the value being the error which
 occurred for that index.
+The supplied \a errorMap parameter may be null, if the client does not desire detailed error information.
+If supplied, it will be empty upon entry to this function.
 The overall operation error will be saved in \a error.
 */
 bool QContactManagerEngine::removeRelationships(const QList<QContactRelationship>& relationships, QMap<int, QContactManager::Error>* errorMap, QContactManager::Error* error)
 {
 Returns true if the contacts were saved successfully, otherwise false.
 The manager might populate \a errorMap (the map of indices of the \a contacts list to
 the error which occurred when saving the contact at that index) for
 every index for which the contact could not be saved, if it is able.
+The supplied \a errorMap parameter may be null, if the client does not desire detailed error information.
+If supplied, it will be empty upon entry to this function.
 The \l QContactManager::error() function will only return \c QContactManager::NoError
 if all contacts were saved successfully.
 For each newly saved contact that was successful, the id of the contact
 in the \a contacts list will be updated with the new value.  If a failure occurs
 in which it was involved removed also.
 The manager might populate \a errorMap (the map of indices of the \a contactIds list to
 the error which occurred when saving the contact at that index) for every
 index for which the contact could not be removed, if it is able.
+The supplied \a errorMap parameter may be null, if the client does not desire detailed error information.
+If supplied, it will be empty upon entry to this function.
 The \l QContactManager::error() function will
 only return \c QContactManager::NoError if all contacts were removed
 successfully.
 If the list contains ids which do not identify a valid contact in the manager, the function will
 // check that the value is allowable
 // if the allowable values is an empty list, any are allowed.
 if (!field.allowableValues().isEmpty()) {
 // if the field datatype is a list, remove non-allowable values
-if (field.dataType() == QVariant::List || field.dataType() == QVariant::StringList) {
+if (field.dataType() == QVariant::List) {
-QList<QVariant> innerValues = variant.toList();
+QVariantList innerValues = variant.toList();
 QMutableListIterator<QVariant> it(innerValues);
+while (it.hasNext()) {
+if (!field.allowableValues().contains(it.next())) {
+it.remove();
+}
+}
+if (innerValues.isEmpty())
+detail.removeValue(key);
+else
+detail.setValue(key, innerValues);
+}
+if (field.dataType() == QVariant::StringList) {
+QStringList innerValues = variant.toStringList();
+QMutableListIterator<QString> it(innerValues);
 while (it.hasNext()) {
 if (!field.allowableValues().contains(it.next())) {
 it.remove();
 }
 }
 else
 *error = QContactManager::DoesNotExistError;
 return conforming;
 }
+/* This implements the string comparison behaviour required for compareVariant, amongst others */
+static inline int compareStrings(const QString& left, const QString& right, Qt::CaseSensitivity sensitivity)
+{
+if (sensitivity == Qt::CaseSensitive) {
+return left.localeAwareCompare(right);
+} else {
+return left.toCaseFolded().localeAwareCompare(right.toCaseFolded());
+}
+}
 /*!
 Compares \a first against \a second.  If the types are
 strings (QVariant::String), the \a sensitivity argument controls
-case sensitivity when comparing.
+case sensitivity when comparing.  Also, when comparing strings,
+a locale aware comparison is used, and if the sensitivity is
+CaseSensitive, strings that are identical under a case insensitive
+sort are then sorted case sensitively within that context.
+For example:
+aaron
+Bob
+Aaron
+aAron
+Carol
+would sort as:
+aaron
+aAron
+Aaron
+Bob
+Carol
 Returns:
 <0 if \a first is less than \a second
 0 if \a first is equal to \a second
 >0 if \a first is greater than \a second.
 case QVariant::ULongLong:
 return first.toULongLong() - second.toULongLong();
 case QVariant::String:
-return first.toString().compare(second.toString(), sensitivity);
+return compareStrings(first.toString(), second.toString(), sensitivity);
 case QVariant::Double:
 {
 const double a = first.toDouble();
 const double b = second.toDouble();
 return true;
 if (matchEnds && var.endsWith(needle, cs))
 return true;
 if (matchContains && var.contains(needle, cs))
 return true;
-if (QString::compare(var, needle, cs) == 0)
+if (compareStrings(var, needle, cs) == 0)
 return true;
 }
 return false;
 } else {
 /* Nope, testing the values as a variant */
 }
 break;
 case QContactFilter::ContactDetailRangeFilter:
 {
+/* The only supported flags are: MatchExactly, MatchFixedString, MatchCaseSensitive */
 const QContactDetailRangeFilter cdf(filter);
 if (cdf.detailDefinitionName().isEmpty())
 return false; /* we do not know which field to check */
 /* See if this contact has one of these details in it */
 /* open or closed interval testing support */
 const int minComp = cdf.rangeFlags() & QContactDetailRangeFilter::ExcludeLower ? 1 : 0;
 const int maxComp = cdf.rangeFlags() & QContactDetailRangeFilter::IncludeUpper ? 1 : 0;
-const bool testMin = cdf.minValue().isValid();
-const bool testMax = cdf.maxValue().isValid();
-/* At this point we know that at least of testMin & testMax is true */
 /* Case sensitivity, for those parts that use it */
 Qt::CaseSensitivity cs = (cdf.matchFlags() & QContactFilter::MatchCaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive;
 /* See what flags are requested, since we're looking at a value */
-if (cdf.matchFlags() & (QContactFilter::MatchEndsWith | QContactFilter::MatchStartsWith | QContactFilter::MatchContains | QContactFilter::MatchFixedString)) {
+if (cdf.matchFlags() & QContactFilter::MatchFixedString) {
 /* We're strictly doing string comparisons here */
-//bool matchStarts = (cdf.matchFlags() & 7) == QContactFilter::MatchStartsWith;
-bool matchEnds = (cdf.matchFlags() & 7) == QContactFilter::MatchEndsWith;
-bool matchContains = (cdf.matchFlags() & 7) == QContactFilter::MatchContains;
-/* Min/Max and contains do not make sense */
-if (matchContains)
-return false;
 QString minVal = cdf.minValue().toString();
 QString maxVal = cdf.maxValue().toString();
-/* Starts with is the normal compare case, endsWith is a bit trickier */
+const bool testMin = !minVal.isEmpty();
+const bool testMax = !maxVal.isEmpty();
 for(int j=0; j < details.count(); j++) {
 const QContactDetail& detail = details.at(j);
+// The detail has to have a field of this type in order to be compared.
+if (!detail.variantValue(cdf.detailFieldName()).isValid())
+continue;
 const QString& var = detail.value(cdf.detailFieldName());
-if (!matchEnds) {
+if (testMin && compareStrings(var, minVal, cs) < minComp)
-// MatchStarts or MatchFixedString
+continue;
-if (testMin && QString::compare(var, minVal, cs) < minComp)
+if (testMax && compareStrings(var, maxVal, cs) >= maxComp)
 continue;
-if (testMax && QString::compare(var, maxVal, cs) >= maxComp)
+return true;
-continue;
-return true;
-} else {
-/* Have to test the length of min & max */
-// using refs means the parameter order is backwards, so negate the result of compare
-if (testMin && -QString::compare(minVal, var.rightRef(minVal.length()), cs) < minComp)
-continue;
-if (testMax && -QString::compare(maxVal, var.rightRef(maxVal.length()), cs) >= maxComp)
-continue;
-return true;
-}
 }
 // Fall through to end
 } else {
+const bool testMin = cdf.minValue().isValid();
+const bool testMax = cdf.maxValue().isValid();
 /* Nope, testing the values as a variant */
 for(int j=0; j < details.count(); j++) {
 const QContactDetail& detail = details.at(j);
 const QVariant& var = detail.variantValue(cdf.detailFieldName());
+// The detail has to have a field of this type in order to be compared.
+if (!var.isValid())
+continue;
 if (testMin && compareVariant(var, cdf.minValue(), cs) < minComp)
 continue;
 if (testMax && compareVariant(var, cdf.maxValue(), cs) >= maxComp)
 continue;
 before \a b according to the sort order, a positive number if \a a should appear after \a b according to the sort order,
 and zero if the two are unable to be sorted.
 */
 int QContactManagerEngine::compareContact(const QContact& a, const QContact& b, const QList<QContactSortOrder>& sortOrders)
 {
-QList<QContactSortOrder> copy = sortOrders;
+foreach(const QContactSortOrder& sortOrder, sortOrders) {
-while (copy.size()) {
-// retrieve the next sort order in the list
-QContactSortOrder sortOrder = copy.takeFirst();
 if (!sortOrder.isValid())
 break;
 // obtain the values which this sort order concerns
 const QVariant& aVal = a.detail(sortOrder.detailDefinitionName()).variantValue(sortOrder.detailFieldName());
 }
 return 0; // or according to id? return (a.id() < b.id() ? -1 : 1);
 }
+/* A functor that returns true iff a is less than b, according to the sortOrders passed in to the
+* ctor.  The sortOrders pointer passed in must remain valid for the lifetime of the functor. */
+class ContactLessThan {
+public:
+ContactLessThan(const QList<QContactSortOrder>* sortOrders) : mSortOrders(sortOrders) {}
+bool operator()(const QContact& a, const QContact& b) const
+{
+return QContactManagerEngine::compareContact(a, b, *mSortOrders) < 0;
+}
+private:
+const QList<QContactSortOrder>* mSortOrders;
+};
 /*!
 Performs insertion sort of the contact \a toAdd into the \a sorted list, according to the provided \a sortOrders list.
-The first QContactSortOrder in the list has the highest priority; if the contact \a toAdd is deemed equal to another
+The first QContactSortOrder in the list has the highest priority: if the contact \a toAdd is deemed equal to another
-in the \a sorted list, the second QContactSortOrder in the list is used (and so on until either the contact is inserted
+in the \a sorted list according to the first QContactSortOrder, the second QContactSortOrder in the list is used (and
-or there are no more sort order objects in the list).
+so on until either the contact is inserted or there are no more sort order objects in the list).
+If a contact is equal to another contact according to all sort orders, it is inserted after the previously-added contact.
 */
 void QContactManagerEngine::addSorted(QList<QContact>* sorted, const QContact& toAdd, const QList<QContactSortOrder>& sortOrders)
 {
 if (sortOrders.count() > 0) {
-for (int i = 0; i < sorted->size(); i++) {
+ContactLessThan lessThan(&sortOrders);
-// check to see if the new contact should be inserted here
+QList<QContact>::iterator it(qUpperBound(sorted->begin(), sorted->end(), toAdd, lessThan));
-int comparison = compareContact(sorted->at(i), toAdd, sortOrders);
+sorted->insert(it, toAdd);
-if (comparison > 0) {
+} else {
-sorted->insert(i, toAdd);
+// no sort order? just add it to the end
-return;
+sorted->append(toAdd);
 }
-}
-}
-// hasn't been inserted yet?  append to the list.
-sorted->append(toAdd);
 }
 /*! Sorts the given list of contacts \a cs according to the provided \a sortOrders */
 QList<QContactLocalId> QContactManagerEngine::sortContacts(const QList<QContact>& cs, const QList<QContactSortOrder>& sortOrders)
 {
 QList<QContactLocalId> sortedIds;
-QList<QContact> sortedContacts;
+QList<QContact> sortedContacts = cs;
 if (!sortOrders.isEmpty()) {
-foreach (const QContact& c, cs) {
+ContactLessThan lessThan(&sortOrders);
-QContactManagerEngine::addSorted(&sortedContacts, c, sortOrders);
+qStableSort(sortedContacts.begin(), sortedContacts.end(), lessThan);
 }
 foreach(const QContact& c, sortedContacts) {
 sortedIds.append(c.localId());
-}
-} else {
-foreach(const QContact& c, cs) {
-sortedIds.append(c.localId());
-}
 }
 return sortedIds;
 }
 /*!
 of the request.  If the new state is different, the stateChanged() signal
 will be emitted by the request.
 */
 void QContactManagerEngine::updateRequestState(QContactAbstractRequest* req, QContactAbstractRequest::State state)
 {
-if (req->d_ptr->m_state != state) {
+if (req) {
-req->d_ptr->m_state = state;
+QMutexLocker ml(&req->d_ptr->m_mutex);
-emit req->stateChanged(state);
+if (req->d_ptr->m_state != state) {
+req->d_ptr->m_state = state;
+ml.unlock();
+emit req->stateChanged(state);
+}
 }
 }
 /*!
 Updates the given QContactLocalIdFetchRequest \a req with the latest results \a result, and operation error \a error.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateContactLocalIdFetchRequest(QContactLocalIdFetchRequest* req, const QList<QContactLocalId>& result, QContactManager::Error error, QContactAbstractRequest::State newState)
 {
-QContactLocalIdFetchRequestPrivate* rd = static_cast<QContactLocalIdFetchRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactLocalIdFetchRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_ids = result;
+QContactLocalIdFetchRequestPrivate* rd = static_cast<QContactLocalIdFetchRequestPrivate*>(ireq.data()->d_ptr);
-bool emitState = rd->m_state != newState;
+QMutexLocker ml(&rd->m_mutex);
-rd->m_state = newState;
+bool emitState = rd->m_state != newState;
-emit req->resultsAvailable();
+rd->m_ids = result;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactFetchRequest \a req with the latest results \a result, and operation error \a error.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateContactFetchRequest(QContactFetchRequest* req, const QList<QContact>& result, QContactManager::Error error, QContactAbstractRequest::State newState)
 {
-QContactFetchRequestPrivate* rd = static_cast<QContactFetchRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactFetchRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_contacts = result;
+QContactFetchRequestPrivate* rd = static_cast<QContactFetchRequestPrivate*>(ireq.data()->d_ptr);
-bool emitState = rd->m_state != newState;
+QMutexLocker ml(&rd->m_mutex);
-rd->m_state = newState;
+bool emitState = rd->m_state != newState;
-emit req->resultsAvailable();
+rd->m_contacts = result;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactRemoveRequest \a req with the operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateContactRemoveRequest(QContactRemoveRequest* req, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactRemoveRequestPrivate* rd = static_cast<QContactRemoveRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactRemoveRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactRemoveRequestPrivate* rd = static_cast<QContactRemoveRequestPrivate*>(ireq.data()->d_ptr);
-bool emitState = rd->m_state != newState;
+QMutexLocker ml(&rd->m_mutex);
-rd->m_state = newState;
+bool emitState = rd->m_state != newState;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactSaveRequest \a req with the latest results \a result, operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateContactSaveRequest(QContactSaveRequest* req, const QList<QContact>& result, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactSaveRequestPrivate* rd = static_cast<QContactSaveRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactSaveRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactSaveRequestPrivate* rd = static_cast<QContactSaveRequestPrivate*>(ireq.data()->d_ptr);
-rd->m_contacts = result;
+QMutexLocker ml(&rd->m_mutex);
 bool emitState = rd->m_state != newState;
-rd->m_state = newState;
+rd->m_contacts = result;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactDetailDefinitionSaveRequest \a req with the latest results \a result, operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateDefinitionSaveRequest(QContactDetailDefinitionSaveRequest* req, const QList<QContactDetailDefinition>& result, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactDetailDefinitionSaveRequestPrivate* rd = static_cast<QContactDetailDefinitionSaveRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactDetailDefinitionSaveRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactDetailDefinitionSaveRequestPrivate* rd = static_cast<QContactDetailDefinitionSaveRequestPrivate*>(req->d_ptr);
-rd->m_definitions = result;
+QMutexLocker ml(&rd->m_mutex);
 bool emitState = rd->m_state != newState;
-rd->m_state = newState;
+rd->m_definitions = result;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactDetailDefinitionRemoveRequest \a req with the operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateDefinitionRemoveRequest(QContactDetailDefinitionRemoveRequest* req, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactDetailDefinitionRemoveRequestPrivate* rd = static_cast<QContactDetailDefinitionRemoveRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactDetailDefinitionRemoveRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactDetailDefinitionRemoveRequestPrivate* rd = static_cast<QContactDetailDefinitionRemoveRequestPrivate*>(req->d_ptr);
-bool emitState = rd->m_state != newState;
+QMutexLocker ml(&rd->m_mutex);
-rd->m_state = newState;
+bool emitState = rd->m_state != newState;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactDetailDefinitionFetchRequest \a req with the latest results \a result, operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateDefinitionFetchRequest(QContactDetailDefinitionFetchRequest* req, const QMap<QString, QContactDetailDefinition>& result, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactDetailDefinitionFetchRequestPrivate* rd = static_cast<QContactDetailDefinitionFetchRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactDetailDefinitionFetchRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactDetailDefinitionFetchRequestPrivate* rd = static_cast<QContactDetailDefinitionFetchRequestPrivate*>(req->d_ptr);
-rd->m_definitions = result;
+QMutexLocker ml(&rd->m_mutex);
 bool emitState = rd->m_state != newState;
-rd->m_state = newState;
+rd->m_definitions = result;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactRelationshipSaveRequest \a req with the latest results \a result, operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateRelationshipSaveRequest(QContactRelationshipSaveRequest* req, const QList<QContactRelationship>& result, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactRelationshipSaveRequestPrivate* rd = static_cast<QContactRelationshipSaveRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactRelationshipSaveRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactRelationshipSaveRequestPrivate* rd = static_cast<QContactRelationshipSaveRequestPrivate*>(req->d_ptr);
-rd->m_relationships = result;
+QMutexLocker ml(&rd->m_mutex);
 bool emitState = rd->m_state != newState;
-rd->m_state = newState;
+rd->m_relationships = result;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactRelationshipRemoveRequest \a req with the operation error \a error, and map of input index to individual error \a errorMap.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateRelationshipRemoveRequest(QContactRelationshipRemoveRequest* req, QContactManager::Error error, const QMap<int, QContactManager::Error>& errorMap, QContactAbstractRequest::State newState)
 {
-QContactRelationshipRemoveRequestPrivate* rd = static_cast<QContactRelationshipRemoveRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactRelationshipRemoveRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_errors = errorMap;
+QContactRelationshipRemoveRequestPrivate* rd = static_cast<QContactRelationshipRemoveRequestPrivate*>(req->d_ptr);
-bool emitState = rd->m_state != newState;
+QMutexLocker ml(&rd->m_mutex);
-rd->m_state = newState;
+bool emitState = rd->m_state != newState;
-emit req->resultsAvailable();
+rd->m_errors = errorMap;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 /*!
 Updates the given QContactRelationshipFetchRequest \a req with the latest results \a result, and operation error \a error.
 In addition, the state of the request will be changed to \a newState.
 If the new request state is different from the previous state, the stateChanged() signal will also be emitted from the request.
 */
 void QContactManagerEngine::updateRelationshipFetchRequest(QContactRelationshipFetchRequest* req, const QList<QContactRelationship>& result, QContactManager::Error error, QContactAbstractRequest::State newState)
 {
-QContactRelationshipFetchRequestPrivate* rd = static_cast<QContactRelationshipFetchRequestPrivate*>(req->d_ptr);
+if (req) {
-req->d_ptr->m_error = error;
+QWeakPointer<QContactRelationshipFetchRequest> ireq(req); // Take this in case the first emit deletes us
-rd->m_relationships = result;
+QContactRelationshipFetchRequestPrivate* rd = static_cast<QContactRelationshipFetchRequestPrivate*>(req->d_ptr);
-bool emitState = rd->m_state != newState;
+QMutexLocker ml(&rd->m_mutex);
-rd->m_state = newState;
+bool emitState = rd->m_state != newState;
-emit req->resultsAvailable();
+rd->m_relationships = result;
-if (emitState)
+rd->m_error = error;
-emit req->stateChanged(newState);
+rd->m_state = newState;
+ml.unlock();
+emit ireq.data()->resultsAvailable();
+if (emitState && ireq)
+emit ireq.data()->stateChanged(newState);
+}
 }
 #include "moc_qcontactmanagerengine.cpp"
 QTM_END_NAMESPACE

changeset 14	6fbed849b4f4
parent 11	06b8e2af4411
child 15	1f895d8a5b2b