Reworte generic sorted() and added filter for "DoNotShowWithCategory" needed

by addressbook

2 files changed, 25 insertions, 12 deletions

diff --git a/libopie2/opiepim/ChangeLog b/libopie2/opiepim/ChangeLog
index e94fa59..52b3f6b 100644
--- a/libopie2/opiepim/ChangeLog
+++ b/libopie2/opiepim/ChangeLog
@@ -1,29 +1,31 @@
+2005-03-18 Stefan Eilers <stefan@eilers-online.net>
+        * Rewrote generic sorted filter and added filter for "DoNotShowWithCategory", needed by addressbook (other filters need to be added!)
 2005-01-16 Stefan Eilers <stefan@eilers-online.net>
         * Added new OPimEventSortVector class, improved OPimSortVector
         * OPimAccessBackend now supports generic sorting.
 2005-01-03 Stefan Eilers <stefan@eilers-online.net>
         * Fixing bug in API documentation
         * Moving hasQuerySettings() and querySettings() to OPimAccessTemplate to be available for all frontends
 2004-12-28  Stefan Eilers <stefan@eilers-online.net>
         * Make improved query by example accessable via frontend
         * Some API documentation improvement
         * Cleanup of backend api..
         * Fixing bug #1501
 2004-11-23  Stefan Eilers <stefan@eilers-online.net>
         * Implement fast and full featured version of sorted() for addressbook
         * Implement generic queryByExample for all Addressboook backends. It allows incremental search.
         * Update of API Documentation
 2004-11-18  Holger Freyther  <freyther@handhelds.org>
         * Every Access can give a set of Occurrences for a period or a datetime
         * QueryByExample, Find, Sort can be generically accessed by OPimBase 
           pointer interface
         * OPimBackendOccurrence gets split up to OPimOccurrences by 
           OPimTemplateBase
         * Add safeCast to various OPimRecords
         * Kill memleak in OPimTodo
         * Add SortVector implementations for OPimTodo and OPimContact
         
         2004-??-??The Opie Team <opie@handhelds.org>
         * Implemented some important modifications to allow to use OPimRecords as it is, without
           have to cast them. This makes it possible to write applications which handling pim
           data in a generic manner (see opimconvertion tool) (eilers)
\ No newline at end of file
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend.cpp b/libopie2/opiepim/backend/ocontactaccessbackend.cpp
index c09427c..6ac9934 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend.cpp
+++ b/libopie2/opiepim/backend/ocontactaccessbackend.cpp
@@ -57,259 +57,270 @@ UIDArray OPimContactAccessBackend::queryByExample( const UIDArray& uid_array, co
                         // Birthday and anniversary are special nonstring fields and should
                         // be handled specially
                         switch ( i ){
                         case Qtopia::Birthday:
                                 queryDate = new QDate( query.birthday() );
                                 checkDate = new QDate( find( uid_array[it] ).birthday() );
                                 // fall through
                         case Qtopia::Anniversary:
                                 if ( queryDate == 0l ){
                                         queryDate = new QDate( query.anniversary() );
                                         checkDate = new QDate( find( uid_array[it] ).anniversary() );
                                 }
 
                                 if ( queryDate->isValid() ){
                                         if(  checkDate->isValid() ){
                                                 if ( settings & OPimContactAccess::DateYear ){
                                                         if ( queryDate->year() != checkDate->year() )
                                                                 allcorrect = false;
                                                 }
                                                 if ( settings & OPimContactAccess::DateMonth ){
                                                         if ( queryDate->month() != checkDate->month() )
                                                                 allcorrect = false;
                                                 }
                                                 if ( settings & OPimContactAccess::DateDay ){
                                                         if ( queryDate->day() != checkDate->day() )
                                                                 allcorrect = false;
                                                 }
                                                 if ( settings & OPimContactAccess::DateDiff ) {
                                                         QDate current;
                                                         // If we get an additional date, we
                                                         // will take this date instead of
                                                         // the current one..
                                                         if ( !d.date().isValid() )
                                                                 current = QDate::currentDate();
                                                         else
                                                                 current = d.date();
 
                                                         // We have to equalize the year, otherwise
                                                         // the search will fail..
                                                         checkDate->setYMD( current.year(),
                                                                            checkDate->month(),
                                                                            checkDate->day() );
                                                         if ( *checkDate < current )
                                                                 checkDate->setYMD( current.year()+1,
                                                                                    checkDate->month(),
                                                                                    checkDate->day() );
 
                                                         // Check whether the birthday/anniversary date is between
                                                         // the current/given date and the maximum date
                                                         // ( maximum time range ) !
                                                         if ( current.daysTo( *queryDate ) >= 0 ){
                                                                 if ( !( ( *checkDate >= current ) &&
                                                                         ( *checkDate <= *queryDate ) ) ){
                                                                         allcorrect = false;
                                                                 }
                                                         }
                                                 }
                                         } else{
                                                 // checkDate is invalid. Therefore this entry is always rejected
                                                 allcorrect = false;
                                         }
                                 }
 
                                 delete queryDate;
                                 queryDate = 0l;
                                 delete checkDate;
                                 checkDate = 0l;
                                 break;
                         default:
                                 /* Just compare fields which are not empty in the query object */
                                 if ( !query.field(i).isEmpty() ){
                                         switch ( settings & ~( OPimContactAccess::IgnoreCase
                                                                | OPimContactAccess::DateDiff
                                                                | OPimContactAccess::DateYear
                                                                | OPimContactAccess::DateMonth
                                                                | OPimContactAccess::DateDay
                                                                | OPimContactAccess::MatchOne
                                                                ) ){
 
                                         case OPimContactAccess::RegExp:{
                                                 QRegExp expr ( query.field(i),
                                                                !(settings & OPimContactAccess::IgnoreCase),
                                                                false );
                                                 if ( expr.find ( find( uid_array[it] ).field(i), 0 ) == -1 )
                                                         allcorrect = false;
                                         }
                                                 break;
                                         case OPimContactAccess::WildCards:{
                                                 QRegExp expr ( query.field(i),
                                                                !(settings & OPimContactAccess::IgnoreCase),
                                                                true );
                                                 if ( expr.find ( find( uid_array[it] ).field(i), 0 ) == -1 )
                                                         allcorrect = false;
                                         }
                                                 break;
                                         case OPimContactAccess::ExactMatch:{
                                                 if (settings & OPimContactAccess::IgnoreCase){
                                                         if ( query.field(i).upper() !=
                                                              find( uid_array[it] ).field(i).upper() )
                                                                 allcorrect = false;
                                                 }else{
                                                         if ( query.field(i) != find( uid_array[it] ).field(i) )
                                                                 allcorrect = false;
                                                 }
                                         }
                                                 break;
                                         }
                                 }
                         }
                 }
                 if ( allcorrect ){
                         m_currentQuery[arraycounter++] = uid_array[it];
                 }
         }
 
         // Shrink to fit..
         m_currentQuery.resize(arraycounter);
 
         return m_currentQuery;
 
 }
 
 const uint OPimContactAccessBackend::querySettings() const
 {
     return ( OPimContactAccess::WildCards
          | OPimContactAccess::IgnoreCase
          | OPimContactAccess::RegExp
          | OPimContactAccess::ExactMatch
          | OPimContactAccess::DateDiff
          | OPimContactAccess::DateYear
          | OPimContactAccess::DateMonth
          | OPimContactAccess::DateDay
          );
 }
 
 bool OPimContactAccessBackend::hasQuerySettings (uint querySettings) const
 {
     /* OPimContactAccess::IgnoreCase, DateDiff, DateYear, DateMonth, DateDay
      * may be added with any of the other settings. IgnoreCase should never used alone.
      * Wildcards, RegExp, ExactMatch should never used at the same time...
      */
 
     // Step 1: Check whether the given settings are supported by this backend
     if ( ( querySettings & (
                 OPimContactAccess::IgnoreCase
                 | OPimContactAccess::WildCards
                 | OPimContactAccess::DateDiff
                 | OPimContactAccess::DateYear
                 | OPimContactAccess::DateMonth
                 | OPimContactAccess::DateDay
                 | OPimContactAccess::RegExp
                 | OPimContactAccess::ExactMatch
                    ) ) != querySettings )
         return false;
 
     // Step 2: Check whether the given combinations are ok..
 
     // IngoreCase alone is invalid
     if ( querySettings == OPimContactAccess::IgnoreCase )
         return false;
 
     // WildCards, RegExp and ExactMatch should never used at the same time
     switch ( querySettings & ~( OPimContactAccess::IgnoreCase
                     | OPimContactAccess::DateDiff
                     | OPimContactAccess::DateYear
                     | OPimContactAccess::DateMonth
                     | OPimContactAccess::DateDay
                     )
          ){
     case OPimContactAccess::RegExp:
         return ( true );
     case OPimContactAccess::WildCards:
         return ( true );
     case OPimContactAccess::ExactMatch:
         return ( true );
     case 0: // one of the upper removed bits were set..
         return ( true );
     default:
         return ( false );
     }
 }
 
 
 UIDArray OPimContactAccessBackend::sorted( const UIDArray& ar, bool asc, int sortOrder,
                                   int filter, const QArray<int>& categories )const {
     odebug << "Using Unaccelerated OPimContactAccessBackend sorted Implementation" << oendl;
 
     Internal::OPimContactSortVector vector(ar.count(), asc, sortOrder );
 
     int item = 0;
     uint cat_count = categories.count();
     uint eve_count = ar.count();
-    bool bCat = filter  & OPimContactAccess::FilterCategory ? true : false;
-    bool catPassed = false;
+    bool contactPassed = false;
     int cat;
 
     for ( uint i = 0; i < eve_count; ++i ) {
         OPimContact contact = find( ar[i], ar, i, Frontend::Forward );
         if ( contact.isEmpty() )
             continue;
 
+        contactPassed = true;
+
+        // Filter all Contacts which have any category
+        if ( (filter & OPimContactAccess::DoNotShowWithCategory) ? true : false ){
+                if ( !contact.categories().isEmpty() )
+                        continue;
+        }
+
         /* show category */
         /* -1 == unfiled */
-        catPassed = false;
         for ( uint cat_nu = 0; cat_nu < cat_count; ++cat_nu ) {
             cat = categories[cat_nu];
-            if ( bCat && cat == -1 ) {
-                if(!contact.categories().isEmpty() )
-                    continue;
-            } else if ( bCat && cat != 0)
-                if (!contact.categories().contains( cat ) )
-                    continue;
-            catPassed = true;
-            break;
+
+            if ( (filter  & OPimContactAccess::FilterCategory) ? true : false ){
+                    if ( cat == -1 ) { 
+                            // We should search unfiled contacts. 
+                            // Unfiled categories have no category set, thus continue if 
+                            // this contact has no empty category.
+                            if( !contact.categories().isEmpty() )
+                                    contactPassed = false;
+                    } else if ( cat != 0 )
+                            if ( !contact.categories().contains( cat ) )
+                                    contactPassed = false;
+            }
+
         }
 
         /*
          * If none of the Categories matched
          * continue
          */
-        if ( !catPassed )
+        if ( !contactPassed )
             continue;
 
         vector.insert(item++, contact );
     }
 
     vector.resize( item );
     /* sort it now */
     vector.sort();
     /* now get the uids */
     UIDArray array( vector.count() );
     for (uint i= 0; i < vector.count(); i++ )
         array[i] = vector.uidAt( i );
 
     return array;
 }
 
 OPimBackendOccurrence::List OPimContactAccessBackend::occurrences( const QDate& start,
                                                                    const QDate& end)const {
     OPimBackendOccurrence::List lst;
 
     UIDArray records = allRecords();
     const uint count = records.count();
     int uid;
 
     for ( uint i = 0; i < count; ++i ) {
         uid = records[i];
         OPimContact contact = find(uid, records, i, Frontend::Forward );
 
         QDate date = contact.anniversary();
         date = QDate( start.year(), date.month(),date.day() );
 
 //        if ( date.isValid() && date.) {
 //        }
     }
 
     return lst;
 }
 }