1 files changed, 12 insertions, 0 deletions

diff --git a/libopie/pim/opimaccesstemplate.h b/libopie/pim/opimaccesstemplate.h
index 6a3a0db..8ff205c 100644
--- a/libopie/pim/opimaccesstemplate.h
+++ b/libopie/pim/opimaccesstemplate.h
@@ -48,48 +48,54 @@ public:
      * was changed.
      * This function will load the external database and afterwards
      * 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
      */
     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;
+ 
+     /** 
+     * return a List of records
+     * that match the regex
+     */
+    virtual List matchRegexp(  const QRegExp &r ) const;   
 
     /**
      * queryByExample.
      * @see otodoaccess, ocontactaccess
      */
     virtual List queryByExample( const T& t, int querySettings, const QDateTime& d = QDateTime() );
 
     /**
      * 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, typename OTemplateBase<T>::CacheDirection dir = OTemplateBase<T>::Forward )const;
 
     /* invalidate cache here */
     /**
      * clears the backend and invalidates the backend
      */
     void clear() ;
 
@@ -160,48 +166,54 @@ OPimAccessTemplate<T>::~OPimAccessTemplate() {
     qWarning("~OPimAccessTemplate<T>");
     delete m_backEnd;
 }
 template <class T>
 bool OPimAccessTemplate<T>::load() {
     invalidateCache();
     return m_backEnd->load();
 }
 template <class T>
 bool OPimAccessTemplate<T>::reload() {
 	invalidateCache();  // zecke: I think this should be added (se)
 	return m_backEnd->reload();
 }
 template <class T>
 bool OPimAccessTemplate<T>::save() {
     return m_backEnd->save();
 }
 template <class T>
 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::allRecords()const {
     QArray<int> ints = m_backEnd->allRecords();
     List lis(ints, this );
     return lis;
 }
 template <class T>
+typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::matchRegexp( const QRegExp &r )const {
+    QArray<int> ints = m_backEnd->matchRegexp( r );
+    List lis(ints, this );
+    return lis;
+}
+template <class T>
 QArray<int> OPimAccessTemplate<T>::records()const {
     return m_backEnd->allRecords();
 }
 template <class T>
 typename OPimAccessTemplate<T>::List
 OPimAccessTemplate<T>::queryByExample( const T& t, int settings, const QDateTime& d ) {
     QArray<int> ints = m_backEnd->queryByExample( t, settings, d );
 
     List lis(ints, this );
     return lis;
 }
 template <class T>
 T OPimAccessTemplate<T>::find( int uid ) const{
     T t = m_backEnd->find( uid );
     cache( t );
     return t;
 }
 template <class T>
 T OPimAccessTemplate<T>::find( int uid, const QArray<int>& ar,
                                uint current, typename OTemplateBase<T>::CacheDirection dir )const {
     /*
      * better do T.isEmpty()
      * after a find this way we would
      * avoid two finds in QCache...