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 {

    49 }

    50 

    51 QMessageFolderFilterPrivate::~QMessageFolderFilterPrivate()

    52 {

    53 }

    54 

    55 bool QMessageFolderFilterPrivate::lessThan(const QMessageFolderFilter filter1, const QMessageFolderFilter filter2)

    56 {

    57     if (filter1.d_ptr->_field == filter2.d_ptr->_field) {

    58         if (filter1.d_ptr->_comparatorType == filter2.d_ptr->_comparatorType) {

    59             return filter1.d_ptr->_comparatorValue < filter2.d_ptr->_comparatorValue;

    60         }

    61         return filter1.d_ptr->_comparatorType < filter2.d_ptr->_comparatorType;

    62     }

    63     return filter1.d_ptr->_field < filter2.d_ptr->_field;

    64 }

    65 

    66 void QMessageFolderFilterPrivate::changeComparatorValuesToOpposite(QMessageFolderFilter& filter)

    67 {

    68     if (filter.d_ptr->_filterList.count() == 0) {

    69         if (filter.d_ptr->_comparatorType == QMessageFolderFilterPrivate::Equality) {

    70             QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter.d_ptr->_comparatorValue));

    71             if (cmp == QMessageDataComparator::Equal) {

    72                 filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual);

    73             } else {

    74                 filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal);

    75             }

    76         } else { // Inclusion

    77             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter.d_ptr->_comparatorValue));

    78             if (cmp == QMessageDataComparator::Includes) {

    79                 filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::Excludes);

    80             } else { // Excludes

    81                 filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::Includes);

    82             }

    83         }

    84     } else {

    85         for (int i=0; i < filter.d_ptr->_filterList.count(); i++) {

    86             for (int j=0; j < filter.d_ptr->_filterList[i].count(); j++) {

    87                 QMessageFolderFilterPrivate::changeComparatorValuesToOpposite(filter.d_ptr->_filterList[i][j]);

    88             }

    89         }

    90     }

    91 }

    92 

    93 void QMessageFolderFilterPrivate::changeANDsAndORsToOpposite(QMessageFolderFilter& filter)

    94 {

    95     if (filter.d_ptr->_filterList.count() > 0) {

    96         QMessageFolderFilter oldFilter = filter;

    97         filter.d_ptr->_filterList.clear();

    98         for (int i=0; i < oldFilter.d_ptr->_filterList.count(); i++) {

    99             if (i == 0) {

   100                 for (int j=0; j < oldFilter.d_ptr->_filterList[i].count(); j++) {

   101                     if (j == 0) {

   102                         filter.d_ptr->_filterList.append(QMessageFolderFilterPrivate::SortedMessageFolderFilterList());

   103                         filter.d_ptr->_filterList[0] << QMessageFolderFilter(oldFilter.d_ptr->_filterList[i][j]);

   104                     } else {

   105                         filter |= oldFilter.d_ptr->_filterList[i][j];

   106                     }

   107                 }

   108             } else {

   109                 QMessageFolderFilter tempFilter;

   110                 for (int j=0; j < oldFilter.d_ptr->_filterList[i].count(); j++) {

   111                     if (j == 0) {

   112                         tempFilter = oldFilter.d_ptr->_filterList[i][j];

   113                     } else {

   114                         tempFilter |= oldFilter.d_ptr->_filterList[i][j];

   115                     }

   116                 }

   117                 filter &= tempFilter;

   118             }

   119         }

   120 

   121         for (int i=0; i < filter.d_ptr->_filterList.count(); i++) {

   122             qSort(filter.d_ptr->_filterList[i].begin(), filter.d_ptr->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan);

   123         }

   124     }

   125 }

   126 

   127 void QMessageFolderFilterPrivate::applyNot(QMessageFolderFilter& filter)

   128 {

   129     QMessageFolderFilterPrivate::changeComparatorValuesToOpposite(filter);

   130     QMessageFolderFilterPrivate::changeANDsAndORsToOpposite(filter);

   131 }

   132 

   133 bool QMessageFolderFilterPrivate::filter(const QMessageFolder &messageFolder, const QMessageFolderFilterPrivate &filter)

   134 {

   135     if ((filter._field == QMessageFolderFilterPrivate::None) &&

   136         (filter._filterList.count() == 0)) {

   137         if (filter._notFilter) {

   138             return false;

   139         } else {

   140             return true;

   141         }

   142     }

   143 

   144     bool retVal = false;

   145 

   146     Qt::CaseSensitivity caseSensitivity = (filter._matchFlags & QMessageDataComparator::MatchCaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive;

   147 

   148     switch (filter._field) {

   149     case QMessageFolderFilterPrivate::Id:

   150         {

   151         if (filter._comparatorType == QMessageFolderFilterPrivate::Equality) {

   152             QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

   153             if (cmp == QMessageDataComparator::Equal) {

   154                 if (messageFolder.id().toString() == filter._value.toString()) {

   155                     retVal = true;

   156                 }

   157             } else { // NotEqual

   158                 if (!(messageFolder.id().toString() == filter._value.toString())) {

   159                     retVal = true;

   160                 }

   161             }

   162         } else if (filter._comparatorType == QMessageFolderFilterPrivate::Inclusion) {

   163             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

   164             if (filter._ids.count() > 0) { // QMessageIdList

   165                 if (cmp == QMessageDataComparator::Includes) {

   166                     if (filter._ids.contains(messageFolder.id())) {

   167                         retVal = true;

   168                     }

   169                 } else { // Excludes

   170                     if (!filter._ids.contains(messageFolder.id())) {

   171                         retVal = true;

   172                     }

   173                 }

   174             } else { // QMessageFilter

   175                 if (cmp == QMessageDataComparator::Includes) {

   176                     // Not supported

   177                 } else { // Excludes

   178                                         // Not supported

   179                 }

   180             }

   181         }

   182         break;

   183         }

   184     case QMessageFolderFilterPrivate::Name:

   185         {

   186         if (filter._comparatorType == QMessageFolderFilterPrivate::Equality) {

   187             QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

   188             if (cmp == QMessageDataComparator::Equal) {

   189                 if (messageFolder.name().compare(filter._value.toString(),caseSensitivity) == 0) {

   190                     retVal = true;

   191                 }

   192             } else { // NotEqual

   193                 if (messageFolder.name().compare(filter._value.toString(),caseSensitivity) != 0) {

   194                     retVal = true;

   195                 }

   196             }

   197         } else if (filter._comparatorType == QMessageFolderFilterPrivate::Inclusion) {

   198             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

   199             if (cmp == QMessageDataComparator::Includes) {

   200                 if (messageFolder.name().contains(filter._value.toString(),caseSensitivity)) {

   201                     retVal = true;

   202                 }

   203             } else { // Excludes

   204                 if (!messageFolder.name().contains(filter._value.toString(),caseSensitivity)) {

   205                     retVal = true;

   206                 }

   207             }

   208         }

   209         break;

   210         }

   211     case QMessageFolderFilterPrivate::Path:

   212         {

   213         if (filter._comparatorType == QMessageFolderFilterPrivate::Equality) {

   214             QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

   215             if (cmp == QMessageDataComparator::Equal) {

   216                 if (messageFolder.path().compare(filter._value.toString(),caseSensitivity) == 0) {

   217                     retVal = true;

   218                 }

   219             } else { // NotEqual

   220                 if (messageFolder.path().compare(filter._value.toString(),caseSensitivity) != 0) {

   221                     retVal = true;

   222                 }

   223             }

   224         } else if (filter._comparatorType == QMessageFolderFilterPrivate::Inclusion) {

   225             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

   226             if (cmp == QMessageDataComparator::Includes) {

   227                 if (messageFolder.path().contains(filter._value.toString(),caseSensitivity)) {

   228                     retVal = true;

   229                 }

   230             } else { // Excludes

   231             if (!messageFolder.path().contains(filter._value.toString(),caseSensitivity)) {

   232                     retVal = true;

   233                 }

   234             }

   235         }

   236         break;

   237         }

   238     case QMessageFolderFilterPrivate::ParentAccountId:

   239         {

   240         if (filter._comparatorType == QMessageFolderFilterPrivate::Equality) {

   241             QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

   242             if (cmp == QMessageDataComparator::Equal) {

   243                 if (messageFolder.parentAccountId().toString() == filter._value.toString()) {

   244                     retVal = true;

   245                 }

   246             } else { // NotEqual

   247                 if (!(messageFolder.parentAccountId().toString() == filter._value.toString())) {

   248                     retVal = true;

   249                 }

   250             }

   251         } else if (filter._comparatorType == QMessageFolderFilterPrivate::Inclusion) { // QMessageAccountFilter

   252             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

   253             if (cmp == QMessageDataComparator::Includes) {

   254                                 // Not supported

   255             } else { // Excludes

   256                                 // Not supported

   257             }

   258         }

   259         break;

   260         }

   261     case QMessageFolderFilterPrivate::ParentFolderId:

   262         {

   263         if (filter._comparatorType == QMessageFolderFilterPrivate::Equality) {

   264             QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

   265             if (cmp == QMessageDataComparator::Equal) {

   266                 if (messageFolder.parentFolderId().toString() == filter._value.toString()) {

   267                     retVal = true;

   268                 }

   269             } else { // NotEqual

   270                 if (!(messageFolder.parentFolderId().toString() == filter._value.toString())) {

   271                     retVal = true;

   272                 }

   273             }

   274         } else if (filter._comparatorType == QMessageFolderFilterPrivate::Inclusion) { // QMessageFolderFilter

   275             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

   276             if (cmp == QMessageDataComparator::Includes) {

   277                                 // Not supported

   278             } else { // Excludes

   279                                 // Not supported

   280             }

   281         }

   282         break;

   283         }

   284     case QMessageFolderFilterPrivate::AncestorFolderIds:

   285         {

   286         if (filter._comparatorType == QMessageFolderFilterPrivate::Inclusion) {

   287             QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

   288             if (!filter._value.isNull()) { // QMessageFolderId

   289                 if (cmp == QMessageDataComparator::Includes) {

   290                                         if (messageFolder.parentFolderId().toString() == filter._value.toString()) {

   291                                                 retVal = true;

   292                                         }

   293                 } else { // Excludes

   294                                         if (!(messageFolder.parentFolderId().toString() == filter._value.toString())) {

   295                                                 retVal = true;

   296                                         }

   297                 }

   298             } else { // QMessageFolderFilter

   299                 if (cmp == QMessageDataComparator::Includes) {

   300                     // Not supported

   301                 } else { // Excludes

   302                     // Not supported

   303                 }

   304             }

   305         }

   306         break;

   307         }

   308     case QMessageFolderFilterPrivate::ParentAccountIdFilter:

   309     case QMessageFolderFilterPrivate::None:

   310         break;

   311     }

   312 

   313     return retVal;

   314 }

   315 

   316 bool QMessageFolderFilterPrivate::filter(const QMessageFolder &messageFolder) const

   317 {

   318     if (!_valid) {

   319         return false;

   320     }

   321 

   322     bool result = false;

   323     if (_filterList.count() == 0) {

   324         result = QMessageFolderFilterPrivate::filter(messageFolder, *this);

   325     } else {

   326         for (int i=0; i < _filterList.count(); i++) {

   327             for (int j=0; j < _filterList[i].count(); j++) {

   328                 result = QMessageFolderFilterPrivate::filter(messageFolder, *_filterList[i][j].d_ptr);

   329                 if (result == false) {

   330                     break;

   331                 }

   332             }

   333             if (result == true) {

   334                 break;

   335             }

   336         }

   337     }

   338     return result;

   339 }

   340 

   341 QMessageFolderFilterPrivate* QMessageFolderFilterPrivate::implementation(const QMessageFolderFilter &filter)

   342 

   343 {

   344     return filter.d_ptr;

   345 }

   346 

   347 QMessageFolderFilter::QMessageFolderFilter()

   348  : d_ptr(new QMessageFolderFilterPrivate(this))

   349 {

   350     d_ptr->_matchFlags = 0;

   351 

   352     d_ptr->_valid = true; // Empty filter is valid

   353     d_ptr->_notFilter = false;

   354     d_ptr->_ids = QMessageFolderIdList();

   355     d_ptr->_value = QVariant();

   356     d_ptr->_field = QMessageFolderFilterPrivate::None;

   357     d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   358     d_ptr->_comparatorValue = 0;

   359     d_ptr->_accountFilter = 0;

   360 }

   361 

   362 QMessageFolderFilter::QMessageFolderFilter(const QMessageFolderFilter &other)

   363  : d_ptr(new QMessageFolderFilterPrivate(this))

   364 {

   365     d_ptr->_accountFilter = 0;

   366     this->operator=(other);

   367 }

   368 

   369 QMessageFolderFilter::~QMessageFolderFilter()

   370 {

   371     delete d_ptr->_accountFilter;

   372     d_ptr->_accountFilter = 0;

   373 

   374     delete d_ptr;

   375 }

   376 

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

   378 {

   379     if (&other == this)

   380         return *this;

   381 

   382     d_ptr->_matchFlags = other.d_ptr->_matchFlags;

   383 

   384     d_ptr->_valid = other.d_ptr->_valid;

   385     d_ptr->_notFilter = other.d_ptr->_notFilter;

   386     d_ptr->_ids = other.d_ptr->_ids;

   387     d_ptr->_value = other.d_ptr->_value;

   388     d_ptr->_field = other.d_ptr->_field;

   389     d_ptr->_comparatorType = other.d_ptr->_comparatorType;

   390     d_ptr->_comparatorValue = other.d_ptr->_comparatorValue;

   391     d_ptr->_filterList = other.d_ptr->_filterList;

   392 

   393     delete d_ptr->_accountFilter;

   394     d_ptr->_accountFilter = 0;

   395     if (other.d_ptr->_accountFilter) {

   396         d_ptr->_accountFilter = new QMessageAccountFilter(*other.d_ptr->_accountFilter);

   397     }

   398 

   399     return *this;

   400 }

   401 

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

   403 {

   404     d_ptr->_matchFlags = matchFlags;

   405 }

   406 

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

   408 {

   409     return d_ptr->_matchFlags;

   410 }

   411 

   412 bool QMessageFolderFilter::isEmpty() const

   413 {

   414     return ((d_ptr->_field == QMessageFolderFilterPrivate::None) &&

   415                 (d_ptr->_notFilter == false) &&

   416             (d_ptr->_filterList.count()) == 0);

   417 }

   418 

   419 bool QMessageFolderFilter::isSupported() const

   420 {

   421     return d_ptr->_valid;

   422 }

   423 

   424 QMessageFolderFilter QMessageFolderFilter::operator~() const

   425 {

   426     QMessageFolderFilter result(*this);

   427     if (result.isEmpty()) {

   428                 result.d_ptr->_notFilter = true;

   429     } else {

   430                 if (result.d_ptr->_notFilter) {

   431                         result.d_ptr->_notFilter = false;

   432                 } else {

   433                         QMessageFolderFilterPrivate::applyNot(result);

   434                 }

   435     }

   436     return result;

   437 }

   438 

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

   440 {

   441     QMessageFolderFilter result(*this);

   442     result &= other;

   443     return result;

   444 }

   445 

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

   447 {

   448     QMessageFolderFilter result(*this);

   449     result |= other;

   450     return result;

   451 }

   452 

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

   454 {

   455     if (&other == this) {

   456         return *this;

   457     }

   458 

   459     if (isEmpty()) {

   460         *this = other;

   461         return *this;

   462     }

   463 

   464     if (other.isEmpty()) {

   465         return *this;

   466     }

   467 

   468         if (d_ptr->_notFilter) {

   469                 return *this;

   470         }

   471 

   472         if (other.d_ptr->_notFilter) {

   473                 *this = other;

   474                 return *this;

   475         }

   476 

   477     if (d_ptr->_filterList.count() == 0) {

   478         QMessageFolderFilter newFilter = QMessageFolderFilter(*this);

   479         d_ptr->_filterList.append(QMessageFolderFilterPrivate::SortedMessageFolderFilterList());

   480         d_ptr->_filterList[0] << newFilter;

   481         d_ptr->_value = QVariant();

   482         d_ptr->_field = QMessageFolderFilterPrivate::None;

   483         d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   484         d_ptr->_comparatorValue = 0;

   485     }

   486     int i = 0;

   487     while (i < d_ptr->_filterList.count()) {

   488         if (other.d_ptr->_filterList.count() == 0) {

   489             d_ptr->_filterList[i] << other;

   490             qSort(d_ptr->_filterList[i].begin(), d_ptr->_filterList[i].end(), QMessageFolderFilterPrivate::lessThan);

   491         } else {

   492             int j = 0;

   493             int k = i;

   494             while (j < other.d_ptr->_filterList.count()) {

   495                 if (j+1 < other.d_ptr->_filterList.count()) {

   496                     d_ptr->_filterList.insert(k+j+1,QMessageFolderFilterPrivate::SortedMessageFolderFilterList());

   497                     d_ptr->_filterList[k+j+1] << d_ptr->_filterList[k+j];

   498                     i++;

   499                 }

   500                 d_ptr->_filterList[k+j] << other.d_ptr->_filterList[j];

   501                 if (d_ptr->_filterList[k+j].count() > 1) {

   502                     qSort(d_ptr->_filterList[k+j].begin(), d_ptr->_filterList[k+j].end(), QMessageFolderFilterPrivate::lessThan);

   503                 }

   504                 j++;

   505             }

   506         }

   507         i++;

   508     }

   509     d_ptr->_valid = d_ptr->_valid & other.d_ptr->_valid;

   510 

   511     return *this;

   512 }

   513 

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

   515 {

   516     if (&other == this) {

   517         return *this;

   518     }

   519 

   520     if (isEmpty()) {

   521         return *this;

   522     }

   523 

   524     if (other.isEmpty()) {

   525         *this = other;

   526         return *this;

   527     }

   528 

   529         if (d_ptr->_notFilter) {

   530                 *this = other;

   531                 return *this;

   532         }

   533 

   534         if (other.d_ptr->_notFilter) {

   535                 return *this;

   536         }

   537 

   538     if (d_ptr->_filterList.count() == 0) {

   539         QMessageFolderFilter newFilter = QMessageFolderFilter(*this);

   540         d_ptr->_filterList.append(QMessageFolderFilterPrivate::SortedMessageFolderFilterList());

   541         d_ptr->_filterList[d_ptr->_filterList.count()-1] << newFilter;

   542         d_ptr->_value = QVariant();

   543         d_ptr->_field = QMessageFolderFilterPrivate::None;

   544         d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   545         d_ptr->_comparatorValue = 0;

   546     }

   547     if (other.d_ptr->_filterList.count() == 0) {

   548         d_ptr->_filterList.append(QMessageFolderFilterPrivate::SortedMessageFolderFilterList());

   549         d_ptr->_filterList[d_ptr->_filterList.count()-1] << other;

   550     } else {

   551         d_ptr->_filterList << other.d_ptr->_filterList;

   552     }

   553     d_ptr->_valid = d_ptr->_valid & other.d_ptr->_valid;

   554 

   555     return *this;

   556 }

   557 

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

   559 {

   560     if (d_ptr->_filterList.count() != other.d_ptr->_filterList.count()) {

   561         return false;

   562     }

   563 

   564     if (d_ptr->_filterList.count() == 0) {

   565         return (d_ptr->_notFilter == other.d_ptr->_notFilter &&

   566                         d_ptr->_field == other.d_ptr->_field &&

   567                 d_ptr->_value == other.d_ptr->_value &&

   568                 d_ptr->_ids == other.d_ptr->_ids &&

   569                 d_ptr->_comparatorType == other.d_ptr->_comparatorType &&

   570                 d_ptr->_comparatorValue == other.d_ptr->_comparatorValue);

   571     } else { // List

   572         for (int i=0; i < d_ptr->_filterList.count(); i++) {

   573             if (d_ptr->_filterList[i].count() != other.d_ptr->_filterList[i].count()) {

   574                 return false;

   575             }

   576             for (int j=0; j < d_ptr->_filterList[i].count(); j++) {

   577                 if (!(d_ptr->_filterList[i][j] == other.d_ptr->_filterList[i][j])) {

   578                     return false;

   579                 }

   580             }

   581         }

   582     }

   583 

   584     if (d_ptr->_accountFilter || other.d_ptr->_accountFilter) {

   585         if (!d_ptr->_accountFilter || !other.d_ptr->_accountFilter || (*d_ptr->_accountFilter != *other.d_ptr->_accountFilter)) {

   586             return false;

   587         }

   588     }

   589 

   590     return true;

   591 }

   592 

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

   594 {

   595     QMessageFolderFilter result;

   596     result.d_ptr->_field = QMessageFolderFilterPrivate::Id;

   597     result.d_ptr->_value = id.toString();

   598     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   599     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   600     result.d_ptr->_valid = true;

   601     return result;

   602 }

   603 

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

   605 {

   606     QMessageFolderFilter result;

   607     result.d_ptr->_field = QMessageFolderFilterPrivate::Id;

   608     result.d_ptr->_ids = ids;

   609     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Inclusion;

   610     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   611     result.d_ptr->_valid = true;

   612     return result;

   613 }

   614 

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

   616 {

   617     QMessageFolderFilter result;

   618     *result.d_ptr = *filter.d_ptr;

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

   620         // Invert the sense of comparison

   621         result = ~result;

   622     }

   623     return result;

   624 }

   625 

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

   627 {

   628     QMessageFolderFilter result;

   629     result.d_ptr->_field = QMessageFolderFilterPrivate::Name;

   630     result.d_ptr->_value = value;

   631     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   632     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   633     result.d_ptr->_valid = true;

   634     return result;

   635 }

   636 

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

   638 {

   639     QMessageFolderFilter result;

   640     result.d_ptr->_field = QMessageFolderFilterPrivate::Name;

   641     result.d_ptr->_value = value;

   642     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Inclusion;

   643     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   644     result.d_ptr->_valid = true;

   645     return result;

   646 }

   647 

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

   649 {

   650     QMessageFolderFilter result;

   651     result.d_ptr->_field = QMessageFolderFilterPrivate::Path;

   652     result.d_ptr->_value = value;

   653     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   654     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   655     result.d_ptr->_valid = true;

   656     return result;

   657 }

   658 

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

   660 {

   661     QMessageFolderFilter result;

   662     result.d_ptr->_field = QMessageFolderFilterPrivate::Path;

   663     result.d_ptr->_value = value;

   664     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Inclusion;

   665     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   666     result.d_ptr->_valid = true;

   667     return result;

   668 }

   669 

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

   671 {

   672     QMessageFolderFilter result;

   673     result.d_ptr->_field = QMessageFolderFilterPrivate::ParentAccountId;

   674     result.d_ptr->_value = id.toString();

   675     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Equality;

   676     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   677     result.d_ptr->_valid = true;

   678     return result;

   679 }

   680 

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

   682 {

   683     QMessageFolderFilter result;

   684     result.d_ptr->_field = QMessageFolderFilterPrivate::ParentAccountIdFilter;

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

   686     result.d_ptr->_comparatorType = QMessageFolderFilterPrivate::Inclusion;

   687     result.d_ptr->_comparatorValue = static_cast<int>(cmp);

   688     return result;

   689 }

   690 

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

   692 {

   693     Q_UNUSED(id)

   694     Q_UNUSED(cmp)

   695     QMessageFolderFilter result;

   696     result.d_ptr->_valid = false;

   697     return result;

   698 }

   699 

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

   701 {

   702     Q_UNUSED(filter)

   703     Q_UNUSED(cmp)

   704     QMessageFolderFilter result;

   705     result.d_ptr->_valid = false;

   706     return result;

   707 }

   708 

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

   710 {

   711     Q_UNUSED(id)

   712     Q_UNUSED(cmp)

   713     QMessageFolderFilter result;

   714     result.d_ptr->_valid = false;

   715     return result;

   716 }

   717 

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

   719 {

   720     Q_UNUSED(filter)

   721     Q_UNUSED(cmp)

   722     QMessageFolderFilter result;

   723     result.d_ptr->_valid = false;

   724     return result;

   725 }

   726 

   727 QTM_END_NAMESPACE