OPIE: libopie2/opiepim/core/opimaccesstemplate.h Source File

00001 /*
00002                              This file is part of the Opie Project
00003                              Copyright (C) Holger Freyther <zecke@handhelds.org>
00004                              Copyright (C) Stefan Eilers <eilers.stefan@epost.de>
00005               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
00006             .=l.
00007            .>+-=
00008  _;:,     .>    :=|.         This program is free software; you can
00009 .> <`_,   >  .   <=          redistribute it and/or  modify it under
00010 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
00011 .="- .-=="i,     .._         License as published by the Free Software
00012  - .   .-<_>     .<>         Foundation; either version 2 of the License,
00013      ._= =}       :          or (at your option) any later version.
00014     .%`+i>       _;_.
00015     .i_,=:_.      -<s.       This program is distributed in the hope that
00016      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
00017     : ..    .:,     . . .    without even the implied warranty of
00018     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
00019   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
00020 ..}^=.=       =       ;      Library General Public License for more
00021 ++=   -.     .`     .:       details.
00022  :     =  ...= . :.=-
00023  -.   .:....=;==+<;          You should have received a copy of the GNU
00024   -_. . .   )=.  =           Library General Public License along with
00025     --        :-=`           this library; see the file COPYING.LIB.
00026                              If not, write to the Free Software Foundation,
00027                              Inc., 59 Temple Place - Suite 330,
00028                              Boston, MA 02111-1307, USA.
00029 */
00030 #ifndef OPIE_PIM_ACCESS_TEMPLATE_H
00031 #define OPIE_PIM_ACCESS_TEMPLATE_H
00032 
00033 /* OPIE */
00034 #include <opie2/opimrecord.h>
00035 #include <opie2/opimaccessbackend.h>
00036 #include <opie2/opimrecordlist.h>
00037 
00038 #include <opie2/opimtemplatebase.h>
00039 #include <opie2/odebug.h>
00040 
00041 /* QT */
00042 #include <qarray.h>
00043 #include <qdatetime.h>
00044 
00045 namespace Opie {
00046 
00047 class OPimAccessTemplatePrivate;
00057 template <class T = OPimRecord >
00058 class OPimAccessTemplate : public OTemplateBase<T> {
00059 public:
00063     enum Access {
00064         Random = 0,
00065         SortedAccess
00066     };
00067     typedef OPimRecordList<T> List;
00068     typedef OPimAccessBackend<T> BackEnd;
00069     typedef OPimCache<T> Cache;
00070 
00072     OPimAccessTemplate( BackEnd* end);
00073     virtual ~OPimAccessTemplate();
00075 
00077     bool load();
00078     virtual bool reload();
00079     bool save();
00080     void clear() ;
00082 
00083 
00084     bool wasChangedExternally()const;
00085 
00087     virtual List allRecords()const;
00088     virtual List matchRegexp(  const QRegExp &r ) const;
00089 
00096     const uint querySettings();
00097 
00103      bool hasQuerySettings ( int querySettings ) const;
00104 
00116     virtual List queryByExample( const T& query, int querySettings, const QDateTime& startperiod = QDateTime() );
00117 
00129     virtual List queryByExample( const OPimRecord* query, int querySettings, const QDateTime& startperiod = QDateTime() );
00142     virtual List queryByExample( const OPimAccessTemplate::List& uidlist, const T& query, int querySettings, 
00143                                  const QDateTime& startperiod = QDateTime() );
00144 
00145     virtual T find( UID uid )const;
00146     virtual T find( UID uid, const QArray<int>&,
00147                     uint current, typename OTemplateBase<T>::CacheDirection dir = OTemplateBase<T>::Forward )const;
00149 
00159     virtual List sorted( const List& list, bool ascending, int sortOrder,
00160                          int sortFilter, int cat )const;
00161 
00171     virtual List sorted( const List& list, bool ascending, int sortOrder,
00172                          int sortFilter, const QArray<UID>& cats )const;
00173 
00182     virtual List sorted( bool ascending, int sortOrder, int sortFilter, int cat )const;
00183 
00192     virtual List sorted( bool ascending, int sortOrder, int sortFilter,
00193                          const QArray<UID>& cats )const;
00198     UIDArray matchRegexpSimple( const QRegExp& r )const;
00199     UIDArray queryByExampleSimple( const OPimRecord*, int, const QDateTime& )const;
00200     UIDArray sortedSimple( const UIDArray&, bool asc, int sortOrder,
00201                            int sortFilter, int cat )const;
00202     UIDArray sortedSimple( const UIDArray&, bool asc, int sortOrder,
00203                            int sortFilter, const QArray<int>& )const;
00204     UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter,
00205                            int cat )const;
00206     UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter,
00207                            const QArray<int>& )const;
00208     OPimOccurrence::List occurrences( const QDate& start,  const QDate& end )const;
00209     OPimOccurrence::List occurrences( const QDateTime& dt )const;
00211 
00213     virtual bool add( const T& t ) ;
00214     bool add( const OPimRecord& );
00215     bool add( const OPimRecord* );
00216     virtual bool remove( const T& t );
00217     bool remove( UID uid );
00218     bool remove( const OPimRecord& );
00219     virtual bool replace( const T& t) ;
00220 
00222 
00223     void setReadAhead( uint count );
00224     void cache( const T& )const;
00225     void setSaneCacheSize( int );
00226 
00227     QArray<UID> records()const;
00228 protected:
00232     void invalidateCache();
00233 
00234     void setBackEnd( BackEnd* end );
00238     BackEnd* backEnd();
00239     BackEnd* m_backEnd;
00240 
00241     Cache m_cache;
00242 
00243 private:
00244     OPimAccessTemplatePrivate *d;
00245 
00246 };
00247 
00252 template <class T>
00253 OPimAccessTemplate<T>::OPimAccessTemplate( BackEnd* end )
00254     : OTemplateBase<T>(), m_backEnd( end )
00255 {
00256     if (end )
00257         end->setFrontend( this );
00258 }
00259 template <class T>
00260 OPimAccessTemplate<T>::~OPimAccessTemplate() {
00261     delete m_backEnd;
00262 }
00263 
00267 template <class T>
00268 bool OPimAccessTemplate<T>::load() {
00269     invalidateCache();
00270     return m_backEnd->load();
00271 }
00272 
00279 template <class T>
00280 bool OPimAccessTemplate<T>::reload() {
00281     invalidateCache();
00282     return m_backEnd->reload();
00283 }
00284 
00290 template <class T>
00291 bool OPimAccessTemplate<T>::save() {
00292     return m_backEnd->save();
00293 }
00294 
00295 
00300 template <class T>
00301 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::allRecords()const {
00302     QArray<int> ints = m_backEnd->allRecords();
00303     List lis(ints, this );
00304     return lis;
00305 }
00306 
00311 template <class T>
00312 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::matchRegexp( const QRegExp &r )const {
00313     QArray<int> ints = m_backEnd->matchRegexp( r );
00314     List lis(ints, this );
00315     return lis;
00316 }
00317 
00321 template <class T>
00322 QArray<int> OPimAccessTemplate<T>::records()const {
00323     return m_backEnd->allRecords();
00324 }
00325 
00326 template <class T>
00327 const uint OPimAccessTemplate<T>::querySettings(){
00328         return m_backEnd->querySettings();
00329 }
00330 
00331 template <class T>
00332 bool OPimAccessTemplate<T>::hasQuerySettings ( int querySettings ) const {
00333         return m_backEnd->hasQuerySettings( querySettings );
00334 }
00335 
00336 
00337 template <class T>
00338 typename OPimAccessTemplate<T>::List
00339 OPimAccessTemplate<T>::queryByExample( const T& t, int settings, const QDateTime& d ) {
00340     QArray<int> ints = m_backEnd->queryByExample( t, settings, d );
00341 
00342     List list(ints, this );
00343     return list;
00344 }
00345 
00346 template <class T>
00347 typename OPimAccessTemplate<T>::List
00348 OPimAccessTemplate<T>::queryByExample( const OPimRecord* t, int settings, const QDateTime& d ) {
00349     T tempInstance;
00350 
00351     if ( t->rtti() == tempInstance.rtti() ) {
00352             QArray<int> ints = m_backEnd->queryByExample( t, settings, d );
00353             List list( ints, this );
00354             return list;
00355     } else {
00356         owarn << "Query not possible: Objecttype mismatch" << oendl;
00357     } 
00358 
00359     return List();
00360 }
00361 
00362 template <class T>
00363 typename OPimAccessTemplate<T>::List
00364 OPimAccessTemplate<T>::queryByExample( const OPimAccessTemplate::List& uidlist, const T& t, int settings, const QDateTime& d ) {
00365     QArray<int> ints = m_backEnd->queryByExample( uidlist.uids(), t, settings, d );
00366 
00367     List list( ints, this );
00368     return list;
00369 }
00370 
00371 
00372 template <class T>
00373 T OPimAccessTemplate<T>::find( UID uid ) const{
00374     // First search in cache..
00375     if ( m_cache.contains( uid ) )
00376             return m_cache.find( uid );
00377 
00378     T t = m_backEnd->find( uid );
00379     cache( t );
00380 
00381     return t;
00382 }
00383 
00384 
00388 template <class T>
00389 T OPimAccessTemplate<T>::find( UID uid, const QArray<int>& ar,
00390                                uint current, typename OTemplateBase<T>::CacheDirection dir )const {
00391     /*
00392      * better do T.isEmpty()
00393      * after a find this way we would
00394      * avoid two finds in QCache...
00395      */
00396     if (m_cache.contains( uid ) )
00397         return m_cache.find( uid );
00398 
00399 
00400     T t = m_backEnd->find( uid, ar, current, dir );
00401     cache( t );
00402     return t;
00403 }
00404 
00408 template <class T>
00409 void OPimAccessTemplate<T>::clear() {
00410     invalidateCache();
00411     m_backEnd->clear();
00412 }
00413 
00414 
00420 template <class T>
00421 bool OPimAccessTemplate<T>::add( const T& t ) {
00422     cache( t );
00423     return m_backEnd->add( t );
00424 }
00425 
00426 template <class T>
00427 bool OPimAccessTemplate<T>::add( const OPimRecord& rec ) {
00428     /* same type */
00429     T tempInstance;
00430     if ( rec.rtti() == tempInstance.rtti() ) {
00431         const T& t = static_cast<const T&>(rec);
00432         return add(t);
00433     } else {
00434         owarn << "Adding not possible: Objecttype mismatch" << oendl;
00435     }
00436     return false;
00437 }
00438 
00445 template <class T>
00446 bool OPimAccessTemplate<T>::add( const OPimRecord* rec) {
00447     /* same type, but pointer  */
00448     T tempInstance;
00449     if ( rec -> rtti() == tempInstance.rtti() ) {
00450         const T* t = static_cast<const T*>(rec);
00451         return add( *t );
00452     } else {
00453         owarn << "Adding not possible: Objecttype mismatch" << oendl;
00454     }
00455     return false;
00456 }
00457 
00463 template <class T>
00464 bool OPimAccessTemplate<T>::remove( const T& t ) {
00465     return remove( t.uid() );
00466 }
00467 
00473 template <class T>
00474 bool OPimAccessTemplate<T>::remove( UID uid ) {
00475     m_cache.remove( uid );
00476     return m_backEnd->remove( uid );
00477 }
00478 template <class T>
00479 bool OPimAccessTemplate<T>::remove( const OPimRecord& rec) {
00480     return remove( rec.uid() );
00481 }
00482 
00488 template <class T>
00489 bool OPimAccessTemplate<T>::replace( const T& t ) {
00490     m_cache.replace( t );
00491     return m_backEnd->replace( t );
00492 }
00493 
00497 template <class T>
00498 void OPimAccessTemplate<T>::invalidateCache() {
00499     m_cache.invalidate();
00500 }
00501 template <class T>
00502 typename OPimAccessTemplate<T>::BackEnd* OPimAccessTemplate<T>::backEnd() {
00503     return m_backEnd;
00504 }
00505 
00511 template <class T>
00512 bool OPimAccessTemplate<T>::wasChangedExternally()const {
00513     return false;
00514 }
00515 template <class T>
00516 void OPimAccessTemplate<T>::setBackEnd( BackEnd* end ) {
00517     m_backEnd = end;
00518     if (m_backEnd )
00519         m_backEnd->setFrontend( this );
00520 }
00521 template <class T>
00522 void OPimAccessTemplate<T>::cache( const T& t ) const{
00523     /* hacky we need to work around the const*/
00524     ((OPimAccessTemplate<T>*)this)->m_cache.add( t );
00525 }
00526 template <class T>
00527 void OPimAccessTemplate<T>::setSaneCacheSize( int size ) {
00528     m_cache.setSize( size );
00529 }
00530 template <class T>
00531 void OPimAccessTemplate<T>::setReadAhead( uint count ) {
00532     m_backEnd->setReadAhead( count );
00533 }
00534 
00535 
00536 template <class T>
00537 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( const OPimAccessTemplate::List& lst,
00538                                                                     bool ascending, int sortOrder,
00539                                                                     int sortFilter, int cat )const {
00540     QArray<int> cats( 1 );
00541     cats[0] = cat;
00542     UIDArray ints = m_backEnd->sorted( lst.uids(), ascending, sortOrder,
00543                                        sortFilter, cats );
00544     return List(ints, this);
00545 }
00546 
00547 template<class T>
00548 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( const OPimAccessTemplate::List& lst,
00549                                                                     bool ascending, int sortOrder,
00550                                                                     int sortFilter, const QArray<UID>& cats )const {
00551     UIDArray ints = m_backEnd->sorted( lst.uids(), ascending, sortOrder,
00552                                        sortFilter, cats );
00553     return List(ints, this);
00554 }
00555 
00556 template<class T>
00557 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( bool ascending, int sortOrder,
00558                                                                     int sortFilter, int cat )const {
00559     QArray<int> cats( 1 );
00560     cats[0] = cat;
00561     UIDArray ints = m_backEnd->sorted( ascending, sortOrder,
00562                                        sortFilter, cats );
00563     return List(ints, this);
00564 }
00565 
00566 template<class T>
00567 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( bool ascending, int sortOrder,
00568                                                                     int sortFilter, const QArray<UID>& cats )const {
00569     UIDArray ints = m_backEnd->sorted( ascending, sortOrder,
00570                                        sortFilter, cats );
00571     return List(ints, this);
00572 }
00573 
00574 template <class T>
00575 OPimOccurrence::List OPimAccessTemplate<T>::occurrences( const QDate& start,
00576                                                          const QDate& end ) const {
00577     /*
00578      * Some magic involved to go from single OPimBackendOccurrence
00579      * to multiple OPimOccurrence's
00580      */
00581     return OPimBase::convertOccurrenceFromBackend( m_backEnd->occurrences( start, end ) );
00582 }
00583 
00584 template<class T>
00585 OPimOccurrence::List OPimAccessTemplate<T>::occurrences( const QDateTime& dt )const {
00586     return OPimBase::convertOccurrenceFromBackend(  m_backEnd->occurrences( dt ) );
00587 }
00588 
00589 /*
00590  *Implementations!!
00591  */
00592 template <class T>
00593 UIDArray OPimAccessTemplate<T>::matchRegexpSimple( const QRegExp &r )const {
00594     return m_backEnd->matchRegexp( r );
00595 }
00596 
00597 template <class T>
00598 UIDArray OPimAccessTemplate<T>::queryByExampleSimple( const OPimRecord* rec,
00599                                                       int settings,
00600                                                       const QDateTime& d )const {
00601     return m_backEnd->queryByExample( rec, settings, d );
00602 }
00603 
00604 template <class T>
00605 UIDArray OPimAccessTemplate<T>::sortedSimple( const UIDArray& lst,
00606                                               bool ascending,
00607                                               int sortOrder, int sortFilter,
00608                                               int cat ) const{
00609     QArray<int> cats( 1 );
00610     cats[0] = cat;
00611     return m_backEnd->sorted( lst, ascending, sortOrder, sortFilter, cats );
00612 }
00613 
00614 template <class T>
00615 UIDArray OPimAccessTemplate<T>::sortedSimple( const UIDArray& lst,
00616                                               bool ascending,
00617                                               int sortOrder, int sortFilter,
00618                                               const QArray<int>& cats ) const{
00619     return m_backEnd->sorted( lst, ascending, sortOrder, sortFilter, cats );
00620 }
00621 
00622 template <class T>
00623 UIDArray OPimAccessTemplate<T>::sortedSimple( bool ascending,
00624                                               int sortOrder, int sortFilter,
00625                                               int cat ) const{
00626     QArray<int> cats( 1 );
00627     cats[0] = cat;
00628 
00629     return m_backEnd->sorted( ascending, sortOrder, sortFilter, cats );
00630 }
00631 
00632 template <class T>
00633 UIDArray OPimAccessTemplate<T>::sortedSimple( bool ascending,
00634                                               int sortOrder, int sortFilter,
00635                                               const QArray<int>& cats ) const{
00636     return m_backEnd->sorted( ascending, sortOrder, sortFilter, cats );
00637 }
00638 }
00639 
00640 #endif