1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "qmessagefolderfilter.h"

    42 #include "qmessagefolderfilter_p.h"

    43 

    44 QTM_BEGIN_NAMESPACE

    45 

    46 QMessageFolderFilterPrivate::QMessageFolderFilterPrivate(QMessageFolderFilter *folderFilter)

    47     : q_ptr(folderFilter),

    48       _operator(Identity),

    49       _criterion(None),

    50       _equality(QMessageDataComparator::Equal),

    51       _inclusion(QMessageDataComparator::Includes),

    52       _matchFlags(0),

    53       _valid(true),

    54       _accountFilter(0),

    55       _folderFilter(0)

    56 {

    57 }

    58 

    59 QMessageFolderFilterPrivate::~QMessageFolderFilterPrivate()

    60 {

    61     foreach(QMessageFolderFilter* filter, _arguments) {

    62         delete filter;

    63     }

    64     _arguments.clear();

    65     delete _accountFilter;

    66     _accountFilter = 0;

    67     delete _folderFilter;

    68     _folderFilter = 0;

    69 }

    70 

    71 QMessageFolderFilterPrivate& QMessageFolderFilterPrivate::operator=(const QMessageFolderFilterPrivate &other)

    72 {

    73     _operator = other._operator;

    74     _criterion = other._criterion;

    75     _ids = other._ids;

    76     _accountIds = other._accountIds;

    77     _value = other._value;

    78     _equality = other._equality;

    79     _inclusion = other._inclusion;

    80     _matchFlags = other._matchFlags;

    81     _valid = other._valid;

    82     foreach(QMessageFolderFilter* filter, _arguments) {

    83         delete filter;

    84     }

    85     _arguments.clear();

    86     foreach(QMessageFolderFilter* _filter, other._arguments) {

    87         _arguments.append(new QMessageFolderFilter(*_filter));

    88     }

    89 

    90     delete _accountFilter;

    91     _accountFilter = 0;

    92     if (other._accountFilter)

    93         _accountFilter = new QMessageAccountFilter(*other._accountFilter);

    94     delete _folderFilter;

    95     _folderFilter = 0;

    96     if (other._folderFilter)

    97         _folderFilter = new QMessageFolderFilter(*other._folderFilter);

    98 

    99     return *this;

   100 }

   101 

   102 bool QMessageFolderFilterPrivate::operator==(const QMessageFolderFilterPrivate &other) const

   103 {

   104     if  ((_operator != other._operator) ||

   105          (_criterion != other._criterion) ||

   106          (_ids != other._ids) ||

   107          (_accountIds != other._accountIds) ||

   108          (_value != other._value) ||

   109          (_equality != other._equality) ||

   110          (_inclusion != other._inclusion) ||

   111          (_matchFlags != other._matchFlags)) {

   112              return false;

   113     }

   114     if (_arguments.count() != other._arguments.count())

   115         return false;

   116     for(int i = 0; i < _arguments.count(); ++i) {

   117         if (*_arguments[i] != *other._arguments[i]) {

   118             return false;

   119         }

   120     }

   121     if (_accountFilter || other._accountFilter) {

   122         if (!_accountFilter || !other._accountFilter || (*_accountFilter != *other._accountFilter)) {

   123             return false;

   124         }

   125     }

   126     if (_folderFilter || other._folderFilter) {

   127         if (!_folderFilter || !other._folderFilter || (*_folderFilter != *other._folderFilter)) {

   128             return false;

   129         }

   130     }

   131     return true;

   132 }

   133 

   134 bool QMessageFolderFilterPrivate::matchesFolder(const QMessageFolderFilter &filter, const MapiFolderPtr &folder)

   135 {

   136     Qt::CaseSensitivity caseSensitivity(Qt::CaseInsensitive);

   137     if (filter.matchFlags() & QMessageDataComparator::MatchCaseSensitive)

   138         caseSensitivity = Qt::CaseSensitive;

   139 

   140     QMessageFolderFilterPrivate *f(filter.d_ptr);

   141     bool result;

   142     bool negate(false);

   143     switch (f->_operator) {

   144     case Not: // fall through

   145     case Nand: // fall through

   146     case Nor:

   147         negate = true;

   148         break;

   149     default:

   150         break;

   151     } // switch

   152 

   153     switch (f->_operator) {

   154     case Identity: // fall through

   155     case Not: {

   156         QMessageFolderFilterPrivate *f(filter.d_ptr);

   157 

   158         if ((f->_criterion == IdEquality) || (f->_criterion == IdInclusion)) {

   159             QMessageFolderId folderId(folder->id());

   160 

   161             if (f->_criterion == IdEquality) {

   162                 bool idEqual(folderId == *f->_ids.begin());

   163                 result = (f->_equality == QMessageDataComparator::Equal ? idEqual : !idEqual);

   164             } else {

   165                 bool idPresent(f->_ids.contains(folderId));

   166                 result = (f->_inclusion == QMessageDataComparator::Includes ? idPresent : !idPresent);

   167             }

   168         } else if ((f->_criterion == NameEquality) || (f->_criterion == NameInclusion)) {

   169             QString folderName(folder->name());

   170 

   171             if (f->_criterion == NameEquality) {

   172                 bool nameEqual(QString::compare(folderName, f->_value, caseSensitivity) == 0);

   173                 result = (f->_equality == QMessageDataComparator::Equal ? nameEqual : !nameEqual);

   174             } else {

   175                 bool namePartialMatch(folderName.contains(f->_value, caseSensitivity));

   176                 result = (f->_inclusion == QMessageDataComparator::Includes ? namePartialMatch : !namePartialMatch);

   177             }

   178         } else if ((f->_criterion == PathEquality) || (f->_criterion == PathInclusion)) {

   179             QString folderPath(QMessageFolder(folder->id()).path());

   180 

   181             if (f->_criterion == PathEquality) {

   182                 bool pathEqual(QString::compare(folderPath, f->_value, caseSensitivity) == 0);

   183                 result = (f->_equality == QMessageDataComparator::Equal ? pathEqual : !pathEqual);

   184             } else {

   185                 bool pathPartialMatch(folderPath.contains(f->_value, caseSensitivity));

   186                 result = (f->_inclusion == QMessageDataComparator::Includes ? pathPartialMatch : !pathPartialMatch);

   187             }

   188         } else if ((f->_criterion == AccountEquality) || (f->_criterion == AccountInclusion)) {

   189             QMessageAccountId accountId(folder->accountId());

   190 

   191             if (f->_criterion == AccountEquality) {

   192                 bool idEqual(accountId == *f->_accountIds.begin());

   193                 result = (f->_equality == QMessageDataComparator::Equal ? idEqual : !idEqual);

   194             } else {

   195                 bool idPresent(f->_accountIds.contains(accountId));

   196                 result = (f->_inclusion == QMessageDataComparator::Includes ? idPresent : !idPresent);

   197             }

   198         } else if ((f->_criterion == ParentEquality) || (f->_criterion == ParentInclusion)) {

   199             QMessageFolderId parentId(folder->parentId());

   200 

   201             if (f->_criterion == ParentEquality) {

   202                 bool idEqual(parentId == *f->_ids.begin());

   203                 result = (f->_equality == QMessageDataComparator::Equal ? idEqual : !idEqual);

   204             } else {

   205                 bool idPresent(f->_ids.contains(parentId));

   206                 result = (f->_inclusion == QMessageDataComparator::Includes ? idPresent : !idPresent);

   207             }

   208         } else if (f->_criterion == AncestorInclusion) {

   209             QSet<QMessageFolderId> ancestorIds(folder->ancestorIds().toSet());

   210             bool idIncluded(ancestorIds.intersect(f->_ids).isEmpty() == false);

   211             result = (f->_inclusion == QMessageDataComparator::Includes ? idIncluded : !idIncluded);

   212         } else { // None

   213             result = (f->_equality == QMessageDataComparator::Equal);

   214         }

   215         break;

   216     }

   217     case And: // fall through

   218     case Nand: {

   219         result = true;

   220         Q_ASSERT(f->_arguments.count());

   221         foreach(QMessageFolderFilter *subfilter, f->_arguments) {

   222             if (!f->matchesFolder(*subfilter, folder)) {

   223                 result = false;

   224                 break;

   225             }

   226         }

   227         break;

   228     }

   229     case Or: // fall through

   230     case Nor: {

   231         result = false;

   232         Q_ASSERT(f->_arguments.count());

   233         foreach(QMessageFolderFilter *subfilter, f->_arguments) {

   234             if (f->matchesFolder(*subfilter, folder)) {

   235                 result = true;

   236                 break;

   237             }

   238         }

   239         break;

   240     }

   241     } // switch

   242 

   243     if (negate)

   244         result = !result;

   245     return result;

   246 }

   247 

   248 QMessageFolderFilter QMessageFolderFilterPrivate::preprocess(QMessageManager::Error *error, MapiSessionPtr session, const QMessageFolderFilter &filter)

   249 {

   250     QMessageFolderFilter result(filter);

   251     QMessageFolderFilterPrivate::preprocess(error, session, &result);

   252     return result;

   253 }

   254 

   255 void QMessageFolderFilterPrivate::preprocess(QMessageManager::Error *error, MapiSessionPtr session, QMessageFolderFilter *filter)

   256 {

   257     if (!filter)

   258         return;

   259 

   260     bool inclusion(filter->d_ptr->_inclusion == QMessageDataComparator::Includes);

   261     QMessageFolderFilter result;

   262     if (inclusion) {

   263         result = ~QMessageFolderFilter();

   264     }

   265     if (filter->d_ptr->_criterion == ParentAccountFilter) {

   266         QList<MapiStorePtr> stores(session->filterStores(error, *filter->d_ptr->_accountFilter));

   267         foreach(MapiStorePtr store, stores) {

   268             if (inclusion) {

   269                 result |= QMessageFolderFilter::byParentAccountId(store->id());

   270             } else {

   271                 result &= QMessageFolderFilter::byParentAccountId(store->id(), QMessageDataComparator::NotEqual);

   272             }

   273         }

   274     } else if (filter->d_ptr->_criterion == ParentFolderFilter) {

   275         QList<MapiFolderPtr> folders(session->filterFolders(error, *filter->d_ptr->_folderFilter));

   276         foreach(MapiFolderPtr folder, folders) {

   277             if (inclusion) {

   278                 result |= QMessageFolderFilter::byParentFolderId(folder->id());

   279             } else {

   280                 result &= QMessageFolderFilter::byParentFolderId(folder->id(), QMessageDataComparator::NotEqual);

   281             }

   282         }

   283     } else if (filter->d_ptr->_criterion == AncestorFolderFilter) {

   284         QList<MapiFolderPtr> folders(session->filterFolders(error, *filter->d_ptr->_folderFilter));

   285         foreach(MapiFolderPtr folder, folders) {

   286             if (inclusion) {

   287                 result |= QMessageFolderFilter::byAncestorFolderIds(folder->id());

   288             } else {

   289                 result &= QMessageFolderFilter::byAncestorFolderIds(folder->id(), QMessageDataComparator::Excludes);

   290             }

   291         }

   292     } else {

   293         foreach(QMessageFolderFilter *subfilter, filter->d_ptr->_arguments) {

   294             preprocess(error, session, subfilter);

   295         }

   296         return;

   297     }

   298     if (filter->d_ptr->_operator == Not) // must be Not or Identity

   299         result = ~result;

   300     *filter = result;

   301 }

   302 

   303 QMessageFolderFilter::QMessageFolderFilter()

   304     : d_ptr(new QMessageFolderFilterPrivate(this))

   305 {

   306 }

   307 

   308 QMessageFolderFilter::QMessageFolderFilter(const QMessageFolderFilter &other)

   309     : d_ptr(new QMessageFolderFilterPrivate(this))

   310 {

   311     this->operator=(other);

   312 }

   313 

   314 QMessageFolderFilter::~QMessageFolderFilter()

   315 {

   316     delete d_ptr;

   317 }

   318 

   319 QMessageFolderFilter& QMessageFolderFilter::operator=(const QMessageFolderFilter& other)

   320 {

   321     *d_ptr = *other.d_ptr;

   322     return *this;

   323 }

   324 

   325 void QMessageFolderFilter::setMatchFlags(QMessageDataComparator::MatchFlags matchFlags)

   326 {

   327     d_ptr->_matchFlags = matchFlags;

   328     d_ptr->_valid = true;

   329     if (d_ptr->_matchFlags & QMessageDataComparator::MatchFullWord)

   330         d_ptr->_valid = false; // Not supported

   331     foreach(QMessageFolderFilter *subfilter, d_ptr->_arguments) {

   332         subfilter->setMatchFlags(matchFlags);

   333     }

   334 }

   335 

   336 QMessageDataComparator::MatchFlags QMessageFolderFilter::matchFlags() const

   337 {

   338     return d_ptr->_matchFlags;

   339 }

   340 

   341 bool QMessageFolderFilter::isEmpty() const

   342 {

   343     return ((d_ptr->_operator == QMessageFolderFilterPrivate::Identity) &&

   344             (d_ptr->_criterion == QMessageFolderFilterPrivate::None) && 

   345             (d_ptr->_equality == QMessageDataComparator::Equal));

   346 }

   347 

   348 bool QMessageFolderFilterPrivate::isNonMatching(const QMessageFolderFilter &filter)

   349 {

   350     return ((filter.d_ptr->_operator == QMessageFolderFilterPrivate::Not) &&

   351             (filter.d_ptr->_criterion == QMessageFolderFilterPrivate::None) && 

   352             (filter.d_ptr->_equality == QMessageDataComparator::Equal));

   353 }

   354 

   355 bool QMessageFolderFilter::isSupported() const

   356 {

   357     return d_ptr->_valid;

   358 }

   359 

   360 QMessageFolderFilter QMessageFolderFilter::operator~() const

   361 {

   362     QMessageFolderFilter result(*this);

   363     int op = static_cast<int>(d_ptr->_operator) + static_cast<int>(QMessageFolderFilterPrivate::Not);

   364     op = op % static_cast<int>(QMessageFolderFilterPrivate::OperatorEnd);

   365     result.d_ptr->_operator = static_cast<QMessageFolderFilterPrivate::Operator>(op);

   366     return result;

   367 }

   368 

   369 QMessageFolderFilter QMessageFolderFilter::operator&(const QMessageFolderFilter& other) const

   370 {

   371     QMessageFolderFilter result(*this);

   372     result &= other;

   373     return result;

   374 }

   375 

   376 QMessageFolderFilter QMessageFolderFilter::operator|(const QMessageFolderFilter& other) const

   377 {

   378     QMessageFolderFilter result(*this);

   379     result |= other;

   380     return result;

   381 }

   382 

   383 const QMessageFolderFilter& QMessageFolderFilter::operator&=(const QMessageFolderFilter& other)

   384 {

   385     if (!d_ptr->_valid || !other.d_ptr->_valid) {

   386         QMessageFolderFilter result;

   387         result.d_ptr->_valid = false;

   388         *this = result;

   389         return *this;

   390     }

   391 

   392     if (&other == this)

   393         return *this;

   394     if (isEmpty()) {

   395         *this = other;

   396         return *this;

   397     }

   398     if (other.isEmpty())

   399         return *this;

   400     if (QMessageFolderFilterPrivate::isNonMatching(*this)) {

   401         return *this;

   402     }

   403     if (QMessageFolderFilterPrivate::isNonMatching(other)) {

   404         *this = other;

   405         return *this;

   406     }

   407 

   408     if (d_ptr->_operator != QMessageFolderFilterPrivate::And) {

   409         QMessageFolderFilter result;

   410         result.d_ptr->_operator = QMessageFolderFilterPrivate::And;

   411         result.d_ptr->_arguments.append(new QMessageFolderFilter(*this));

   412         *this = result;

   413     }

   414     d_ptr->_arguments.append(new QMessageFolderFilter(other));

   415     return *this;

   416 }

   417 

   418 const QMessageFolderFilter& QMessageFolderFilter::operator|=(const QMessageFolderFilter& other)

   419 {

   420     if (!d_ptr->_valid || !other.d_ptr->_valid) {

   421         QMessageFolderFilter result;

   422         result.d_ptr->_valid = false;

   423         *this = result;

   424         return *this;

   425     }

   426 

   427     if (&other == this)

   428         return *this;

   429     if (isEmpty())

   430         return *this;

   431     if (other.isEmpty()) {

   432         *this = other;

   433         return *this;

   434     }

   435     if (QMessageFolderFilterPrivate::isNonMatching(*this)) {

   436         *this = other;

   437         return *this;

   438     }

   439     if (QMessageFolderFilterPrivate::isNonMatching(other)) {

   440         return *this;

   441     }

   442 

   443     if (d_ptr->_operator != QMessageFolderFilterPrivate::Or) {

   444         QMessageFolderFilter result;

   445         result.d_ptr->_operator = QMessageFolderFilterPrivate::Or;

   446         result.d_ptr->_arguments.append(new QMessageFolderFilter(*this));

   447         *this = result;

   448     }

   449     d_ptr->_arguments.append(new QMessageFolderFilter(other));

   450     return *this;

   451 }

   452 

   453 bool QMessageFolderFilter::operator==(const QMessageFolderFilter& other) const

   454 {

   455     return (*d_ptr == *other.d_ptr);

   456 }

   457 

   458 QMessageFolderFilter QMessageFolderFilter::byId(const QMessageFolderId &id, QMessageDataComparator::EqualityComparator cmp)

   459 {

   460     if (!id.isValid()) {

   461         QMessageFolderFilter result(~QMessageFolderFilter()); // non-matching

   462         if (QMessageDataComparator::NotEqual == cmp) {

   463             result = ~result;

   464         }

   465         return result;

   466     }

   467 

   468     QMessageFolderFilter result;

   469     result.d_ptr->_ids.insert(id);

   470     result.d_ptr->_equality = cmp;

   471     result.d_ptr->_criterion = QMessageFolderFilterPrivate::IdEquality;

   472     return result;

   473 }

   474 

   475 QMessageFolderFilter QMessageFolderFilter::byId(const QMessageFolderIdList &ids, QMessageDataComparator::InclusionComparator cmp)

   476 {

   477     QMessageFolderIdList validIds;

   478     foreach(QMessageFolderId id, ids) {

   479         if (id.isValid()) {

   480             validIds.append(id);

   481         }

   482     }

   483     if (validIds.isEmpty()) {

   484         QMessageFolderFilter result(~QMessageFolderFilter()); // non-matching

   485         if (QMessageDataComparator::Excludes == cmp) {

   486             result = ~result;

   487         }

   488         return result;

   489     }

   490 

   491     QMessageFolderFilter result;

   492     result.d_ptr->_ids = validIds.toSet();

   493     result.d_ptr->_inclusion = cmp;

   494     result.d_ptr->_criterion = QMessageFolderFilterPrivate::IdInclusion;

   495     return result;

   496 }

   497 

   498 QMessageFolderFilter QMessageFolderFilter::byId(const QMessageFolderFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   499 {

   500     QMessageFolderFilter result;

   501     *result.d_ptr = *filter.d_ptr;

   502     if (cmp == QMessageDataComparator::Excludes) {

   503         // Invert the sense of comparison

   504         result = ~result;

   505     }

   506     return result;

   507 }

   508 

   509 QMessageFolderFilter QMessageFolderFilter::byName(const QString &value, QMessageDataComparator::EqualityComparator cmp)

   510 {

   511     QMessageFolderFilter result;

   512     result.d_ptr->_value = value;

   513     result.d_ptr->_equality = cmp;

   514     result.d_ptr->_criterion = QMessageFolderFilterPrivate::NameEquality;

   515     return result;

   516 }

   517 

   518 QMessageFolderFilter QMessageFolderFilter::byName(const QString &value, QMessageDataComparator::InclusionComparator cmp)

   519 {

   520     QMessageFolderFilter result;

   521     result.d_ptr->_value = value;

   522     result.d_ptr->_inclusion = cmp;

   523     result.d_ptr->_criterion = QMessageFolderFilterPrivate::NameInclusion;

   524     return result;

   525 }

   526 

   527 QMessageFolderFilter QMessageFolderFilter::byPath(const QString &value, QMessageDataComparator::EqualityComparator cmp)

   528 {

   529     QMessageFolderFilter result;

   530     result.d_ptr->_value = value;

   531     result.d_ptr->_equality = cmp;

   532     result.d_ptr->_criterion = QMessageFolderFilterPrivate::PathEquality;

   533     return result;

   534 }

   535 

   536 QMessageFolderFilter QMessageFolderFilter::byPath(const QString &value, QMessageDataComparator::InclusionComparator cmp)

   537 {

   538     QMessageFolderFilter result;

   539     result.d_ptr->_value = value;

   540     result.d_ptr->_inclusion = cmp;

   541     result.d_ptr->_criterion = QMessageFolderFilterPrivate::PathInclusion;

   542     return result;

   543 }

   544 

   545 QMessageFolderFilter QMessageFolderFilter::byParentAccountId(const QMessageAccountId &id, QMessageDataComparator::EqualityComparator cmp)

   546 {

   547     if (!id.isValid()) {

   548         QMessageFolderFilter result(~QMessageFolderFilter()); // non-matching

   549         if (QMessageDataComparator::NotEqual == cmp) {

   550             result = ~result;

   551         }

   552         return result;

   553     }

   554     QMessageFolderFilter result;

   555     result.d_ptr->_accountIds.insert(id);

   556     result.d_ptr->_equality = cmp;

   557     result.d_ptr->_criterion = QMessageFolderFilterPrivate::AccountEquality;

   558     return result;

   559 }

   560 

   561 QMessageFolderFilter QMessageFolderFilter::byParentAccountId(const QMessageAccountFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   562 {

   563     QMessageFolderFilter result;

   564     result.d_ptr->_accountFilter = new QMessageAccountFilter(filter);

   565     result.d_ptr->_inclusion = cmp;

   566     result.d_ptr->_criterion = QMessageFolderFilterPrivate::ParentAccountFilter;

   567     return result;

   568 }

   569 

   570 QMessageFolderFilter QMessageFolderFilter::byParentFolderId(const QMessageFolderId &id, QMessageDataComparator::EqualityComparator cmp)

   571 {

   572     QMessageFolderFilter result;

   573     result.d_ptr->_ids.insert(id);

   574     result.d_ptr->_equality = cmp;

   575     result.d_ptr->_criterion = QMessageFolderFilterPrivate::ParentEquality;

   576     return result;

   577 }

   578 

   579 QMessageFolderFilter QMessageFolderFilter::byParentFolderId(const QMessageFolderFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   580 {

   581     QMessageFolderFilter result;

   582     result.d_ptr->_folderFilter = new QMessageFolderFilter(filter);

   583     result.d_ptr->_inclusion = cmp;

   584     result.d_ptr->_criterion = QMessageFolderFilterPrivate::ParentFolderFilter;

   585     return result;

   586 }

   587 

   588 QMessageFolderFilter QMessageFolderFilter::byAncestorFolderIds(const QMessageFolderId &id, QMessageDataComparator::InclusionComparator cmp)

   589 {

   590     QMessageFolderFilter result;

   591     result.d_ptr->_ids.insert(id);

   592     result.d_ptr->_inclusion = cmp;

   593     result.d_ptr->_criterion = QMessageFolderFilterPrivate::AncestorInclusion;

   594     return result;

   595 }

   596 

   597 QMessageFolderFilter QMessageFolderFilter::byAncestorFolderIds(const QMessageFolderFilter &filter, QMessageDataComparator::InclusionComparator cmp)

   598 {

   599     QMessageFolderFilter result;

   600     result.d_ptr->_folderFilter = new QMessageFolderFilter(filter);

   601     result.d_ptr->_inclusion = cmp;

   602     result.d_ptr->_criterion = QMessageFolderFilterPrivate::AncestorFolderFilter;

   603     return result;

   604 }

   605 

   606 QTM_END_NAMESPACE