3 files changed, 22 insertions, 3 deletions

diff --git a/libopie/pim/opimaccessbackend.h b/libopie/pim/opimaccessbackend.h
index 27d3cb8..0bd2723 100644
--- a/libopie/pim/opimaccessbackend.h
+++ b/libopie/pim/opimaccessbackend.h
@@ -62,66 +62,80 @@ public:
      * clear the back end
      */
     virtual void clear() = 0;
 
     /**
      * add T
      */
     virtual bool add( const T& t ) = 0;
 
     /**
      * remove
      */
     virtual bool remove( int uid ) = 0;
 
     /**
      * replace a record with T.uid()
      */
     virtual bool replace( const T& t ) = 0;
 
     /*
      * setTheFrontEnd!!!
      */
     void setFrontend( Frontend* front );
 
+    /**
+     * set the read ahead count
+     */
+    void setReadAhead( uint count );
 protected:
     void cache( const T& t )const;
 
     /**
      * use a prime number here!
      */
     void setSaneCacheSize( int );
 
+    uint readAhead()const;
+
 private:
     Frontend* m_front;
+    uint m_read;
 
 };
 
 template <class T>
 OPimAccessBackend<T>::OPimAccessBackend() {
     m_front = 0l;
 }
 template <class T>
 OPimAccessBackend<T>::~OPimAccessBackend() {
 
 }
 template <class T>
 void OPimAccessBackend<T>::setFrontend( Frontend* fr ) {
     m_front = fr;
 }
 template <class T>
 void OPimAccessBackend<T>::cache( const T& t )const {
     if (m_front )
         m_front->cache( t );
 }
 template <class T>
 void OPimAccessBackend<T>::setSaneCacheSize( int size) {
     if (m_front )
         m_front->setSaneCacheSize( size );
 }
 template <class T>
 T OPimAccessBackend<T>::find( int uid, const QArray<int>&,
                               uint, Frontend::CacheDirection )const {
     return find( uid );
 }
-
+template <class T>
+void OPimAccessBackend<T>::setReadAhead( uint count ) {
+    m_read = count;
+}
+template <class T>
+uint OPimAccessBackend<T>::readAhead()const {
+    return m_read;
+}
 #endif
diff --git a/libopie/pim/opimaccesstemplate.h b/libopie/pim/opimaccesstemplate.h
index 50cb1e4..c5523a8 100644
--- a/libopie/pim/opimaccesstemplate.h
+++ b/libopie/pim/opimaccesstemplate.h
@@ -44,49 +44,49 @@ public:
      * rejoin the local changes. Therefore the local database will be set consistent.
      */
     virtual bool reload();
 
     /** Save contacts database.
      * Save is more a "commit". After calling this function, all changes are public available.
      * @return true if successful
      */
     virtual bool save();
 
     /**
      * if the resource was changed externally
      * You should use the signal handling instead of polling possible changes !
      * zecke: Do you implement a signal for otodoaccess ?
      */
     bool wasChangedExternally()const;
 
     /**
      * return a List of records
      * you can iterate over them
      */
     virtual List allRecords()const;
 
     /**
-     * queryByExample. 
+     * queryByExample.
      * @see otodoaccess, ocontactaccess
      */
     virtual List queryByExample( const T& t, int querySettings );
 
     /**
      * find the OPimRecord uid
      */
     virtual T find( int uid )const;
 
     /**
      * read ahead cache find method ;)
      */
     virtual T find( int uid, const QArray<int>&,
                     uint current, CacheDirection dir = Forward )const;
 
     /* invalidate cache here */
     /**
      * clears the backend and invalidates the backend
      */
     virtual void clear() ;
 
     /**
      * add T to the backend
      * @param t The item to add.
@@ -95,48 +95,49 @@ public:
     virtual bool add( const T& t ) ;
 
     /* only the uid matters */
     /**
      * remove T from the backend
      * @param t The item to remove
      * @return <i>true</i> if successful.
      */
     virtual bool remove( const T& t );
 
     /**
      * remove the OPimRecord with uid
      * @param uid The ID of the item to remove
      * @return <i>true</i> if successful.
      */
     virtual bool remove( int uid );
 
     /**
      * replace T from backend
      * @param t The item to replace
      * @return <i>true</i> if successful.
      */
     virtual bool replace( const T& t) ;
 
+    void setReadAhead( uint count );
     /**
      * @internal
      */
     void cache( const T& )const;
     void setSaneCacheSize( int );
 protected:
     /**
      * invalidate the cache
      */
     void invalidateCache();
 
     void setBackEnd( BackEnd* end );
     /**
      * returns the backend
      */
     BackEnd* backEnd();
     BackEnd* m_backEnd;
     Cache m_cache;
 
 };
 
 template <class T>
 OPimAccessTemplate<T>::OPimAccessTemplate( BackEnd* end )
     : OTemplateBase<T>(), m_backEnd( end )
@@ -230,25 +231,29 @@ void OPimAccessTemplate<T>::invalidateCache() {
 }
 template <class T>
 OPimAccessTemplate<T>::BackEnd* OPimAccessTemplate<T>::backEnd() {
     return m_backEnd;
 }
 template <class T>
 bool OPimAccessTemplate<T>::wasChangedExternally()const {
     return false;
 }
 template <class T>
 void OPimAccessTemplate<T>::setBackEnd( BackEnd* end ) {
     m_backEnd = end;
     if (m_backEnd )
         m_backEnd->setFrontend( this );
 }
 template <class T>
 void OPimAccessTemplate<T>::cache( const T& t ) const{
     /* hacky we need to work around the const*/
     ((OPimAccessTemplate<T>*)this)->m_cache.add( t );
 }
 template <class T>
 void OPimAccessTemplate<T>::setSaneCacheSize( int size ) {
     m_cache.setSize( size );
 }
+template <class T>
+void OPimAccessTemplate<T>::setReadAhead( uint count ) {
+    m_backEnd->setReadAhead( count );
+}
 #endif
diff --git a/libopie/pim/otodoaccesssql.cpp b/libopie/pim/otodoaccesssql.cpp
index 9ef6b7c..8c2ea3a 100644
--- a/libopie/pim/otodoaccesssql.cpp
+++ b/libopie/pim/otodoaccesssql.cpp
@@ -265,51 +265,51 @@ bool OTodoAccessBackendSQL::load(){
     return true;
 }
 bool OTodoAccessBackendSQL::reload(){
     return load();
 }
 
 bool OTodoAccessBackendSQL::save(){
     return m_driver->close();
 }
 QArray<int> OTodoAccessBackendSQL::allRecords()const {
     if (m_dirty )
         update();
 
     return m_uids;
 }
 QArray<int> OTodoAccessBackendSQL::queryByExample( const OTodo& , int  ){
     QArray<int> ints(0);
     return ints;
 }
 OTodo OTodoAccessBackendSQL::find(int uid ) const{
     FindQuery query( uid );
     return todo( m_driver->query(&query) );
 
 }
-#define CACHE 32
 OTodo OTodoAccessBackendSQL::find( int uid, const QArray<int>& ints,
                                    uint cur, Frontend::CacheDirection dir ) const{
+    int CACHE = readAhead();
     qWarning("searching for %d", uid );
     QArray<int> search( CACHE );
     uint size =0;
     OTodo to;
 
     // we try to cache CACHE items
     switch( dir ) {
         /* forward */
     case 0:
         for (uint i = cur; i < ints.count() && size < CACHE; i++ ) {
             qWarning("size %d %d", size,  ints[i] );
             search[size] = ints[i];
             size++;
         }
         break;
         /* reverse */
     case 1:
         for (uint i = cur; i != 0 && size <  CACHE; i-- ) {
             search[size] = ints[i];
             size++;
         }
         break;
     }
     search.resize( size );