Some modifications to alow use of generic OPimRecords without need to

cast them manually to the right type

9 files changed, 64 insertions, 14 deletions

diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp b/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
index 401a3c1..14207be 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
@@ -409,48 +409,49 @@ void OPimContactAccessBackend_SQL::clear ()
 	ClearQuery cle;
 	OSQLResult res = m_driver->query( &cle );
 
 	reload();
 }
 
 bool OPimContactAccessBackend_SQL::wasChangedExternally()
 {
 	return false;
 }
 
 QArray<int> OPimContactAccessBackend_SQL::allRecords() const
 {
 
 	// FIXME: Think about cute handling of changed tables..
 	// Thus, we don't have to call update here...
  	if ( m_changed )  
 		((OPimContactAccessBackend_SQL*)this)->update();
 	
 	return m_uids;
 }
 
 bool OPimContactAccessBackend_SQL::add ( const OPimContact &newcontact )
 {
+	qDebug("add in contact SQL-Backend");
 	InsertQuery ins( newcontact );
 	OSQLResult res = m_driver->query( &ins );
 
 	if ( res.state() == OSQLResult::Failure )
 		return false;
 
 	int c = m_uids.count();
 	m_uids.resize( c+1 );
 	m_uids[c] = newcontact.uid();
 	
 	return true;
 }
 
 
 bool OPimContactAccessBackend_SQL::remove ( int uid )
 {
 	RemoveQuery rem( uid );
 	OSQLResult res = m_driver->query(&rem );
 
 	if ( res.state() == OSQLResult::Failure )
 		return false;
 
 	m_changed = true;
 
diff --git a/libopie2/opiepim/core/ocontactaccess.cpp b/libopie2/opiepim/core/ocontactaccess.cpp
index 4f9b504..67f267f 100644
--- a/libopie2/opiepim/core/ocontactaccess.cpp
+++ b/libopie2/opiepim/core/ocontactaccess.cpp
@@ -31,48 +31,49 @@
  * ToDo: XML-Backend: Automatic reload if something was changed...
  *
  *
  */
 
 #include "ocontactaccess.h"
 #include "obackendfactory.h"
 
 #include <qasciidict.h>
 #include <qdatetime.h>
 #include <qfile.h>
 #include <qregexp.h>
 #include <qlist.h>
 #include <qcopchannel_qws.h>
 
 //#include <qpe/qcopenvelope_qws.h>
 #include <qpe/global.h>
 
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 
 #include <opie2/ocontactaccessbackend_xml.h>
+#include <opie2/opimresolver.h>
 
 namespace Opie {
 
 OPimContactAccess::OPimContactAccess ( const QString appname, const QString ,
 			 OPimContactAccessBackend* end, bool autosync ):
 	OPimAccessTemplate<OPimContact>( end )
 {
         /* take care of the backend. If there is no one defined, we
 	 * will use the XML-Backend as default (until we have a cute SQL-Backend..).
 	 */
         if( end == 0 ) {
 		qWarning ("Using BackendFactory !");
 		end = OBackendFactory<OPimContactAccessBackend>::Default( "contact", appname );
         }
 	// Set backend locally and in template
         m_backEnd = end;
 	OPimAccessTemplate<OPimContact>::setBackEnd (end);
 
 
 	/* Connect signal of external db change to function */
 	QCopChannel *dbchannel = new QCopChannel( "QPE/PIM", this );
 	connect( dbchannel, SIGNAL(received(const QCString&,const QByteArray&)),
                this, SLOT(copMessage(const QCString&,const QByteArray&)) );
 	if ( autosync ){
@@ -128,25 +129,30 @@ OPimRecordList<OPimContact> OPimContactAccess::sorted( bool ascending, int sortO
 }
 
 
 bool OPimContactAccess::wasChangedExternally()const
 {
 	return ( m_backEnd->wasChangedExternally() );
 }
 
 
 void OPimContactAccess::copMessage( const QCString &msg, const QByteArray & )
 {
 	if ( msg == "addressbookUpdated()" ){
 		qWarning ("OPimContactAccess: Received addressbokUpdated()");
 		emit signalChanged ( this );
 	} else if ( msg == "flush()" ) {
 		qWarning ("OPimContactAccess: Received flush()");
 		save ();
 	} else if ( msg == "reload()" ) {
 		qWarning ("OPimContactAccess: Received reload()");
 		reload ();
 		emit signalChanged ( this );
 	}
 }
 
+int OPimContactAccess::rtti() const
+{
+	return OPimResolver::AddressBook;
+}
+
 }
diff --git a/libopie2/opiepim/core/ocontactaccess.h b/libopie2/opiepim/core/ocontactaccess.h
index cf5333a..4429b6f 100644
--- a/libopie2/opiepim/core/ocontactaccess.h
+++ b/libopie2/opiepim/core/ocontactaccess.h
@@ -107,48 +107,53 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact>
 	/** Return all possible settings.
 	 *  @return All settings provided by the current backend
 	 * (i.e.: query_WildCards & query_IgnoreCase)
 	 */
 	const uint querySettings();
 
 	/** Check whether settings are correct.
 	 * @return <i>true</i> if the given settings are correct and possible.
 	 */
 	bool hasQuerySettings ( int querySettings ) const;
 
 	/**
 	 * if the resource was changed externally.
 	 * You should use the signal instead of polling possible changes !
 	 */
 	bool wasChangedExternally()const;
 
 
 	/** Save contacts database.
 	 * Save is more a "commit". After calling this function, all changes are public available.
 	 * @return true if successful
 	 */
 	bool save();
 
+	/** 
+	 * Return identification of used records
+	 */
+	int rtti() const;
+
  signals:
 	/* Signal is emitted if the database was changed. Therefore
 	 * we may need to reload to stay consistent.
 	 * @param which Pointer to the database who created this event. This pointer
 	 * is useful if an application has to handle multiple databases at the same time.
 	 * @see reload()
 	 */
 	void signalChanged ( const OPimContactAccess *which );
 
 
  private:
 	// class OPimContactAccessPrivate;
 	// OPimContactAccessPrivate* d;
         OPimContactAccessBackend *m_backEnd;
         bool m_loading:1;
 
  private slots:
 	void copMessage( const QCString &msg, const QByteArray &data );
 
  private:
         class Private;
 	Private *d;
 
 };
diff --git a/libopie2/opiepim/core/odatebookaccess.cpp b/libopie2/opiepim/core/odatebookaccess.cpp
index ac310c1..29298ea 100644
--- a/libopie2/opiepim/core/odatebookaccess.cpp
+++ b/libopie2/opiepim/core/odatebookaccess.cpp
@@ -7,48 +7,49 @@
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 #include <opie2/obackendfactory.h>
 #include <opie2/odatebookaccess.h>
+#include <opie2/opimresolver.h>
 
 namespace Opie {
 /**
  * Simple constructor
  * It takes a ODateBookAccessBackend as parent. If it is 0 the default implementation
  * will be used!
  * @param back The backend to be used or 0 for the default backend
  * @param ac What kind of access is intended
  */
 ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access ac )
     : OPimAccessTemplate<OPimEvent>( back )
 {
     if (!back )
         back = OBackendFactory<ODateBookAccessBackend>::Default("datebook", QString::null );
 
     m_backEnd = back;
     setBackEnd( m_backEnd );
 }
 ODateBookAccess::~ODateBookAccess() {
 }
 
 /**
  * @return all events available
  */
@@ -87,26 +88,30 @@ ODateBookAccess::List ODateBookAccess::nonRepeats()const {
 OEffectiveEvent::ValueList ODateBookAccess::effectiveEvents( const QDate& from, const QDate& to ) const {
     return m_backEnd->effectiveEvents( from, to );
 }
 /**
  * @return all events at a given datetime
  */
 OEffectiveEvent::ValueList ODateBookAccess::effectiveEvents( const QDateTime& start ) const {
     return m_backEnd->effectiveEvents( start );
 }
 
 /**
  * @return non repeating dates in the time span between from and to
  * @param from Include all events from...
  * @param to Include all events to...
  */
 OEffectiveEvent::ValueList ODateBookAccess::effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const {
     return m_backEnd->effectiveNonRepeatingEvents( from, to );
 }
 /**
  * @return all non repeating events at a given datetime
  */
 OEffectiveEvent::ValueList ODateBookAccess::effectiveNonRepeatingEvents( const QDateTime& start ) const {
     return m_backEnd->effectiveNonRepeatingEvents( start );
 }
+int ODateBookAccess::rtti() const
+{
+	return OPimResolver::DateBook;
+}
 
 }
diff --git a/libopie2/opiepim/core/odatebookaccess.h b/libopie2/opiepim/core/odatebookaccess.h
index 6c9290f..c6c3598 100644
--- a/libopie2/opiepim/core/odatebookaccess.h
+++ b/libopie2/opiepim/core/odatebookaccess.h
@@ -43,33 +43,39 @@ namespace Opie {
  * destructing and creating the object
  *
  * @author Holger Freyther, Stefan Eilers
  */
 class ODateBookAccess : public OPimAccessTemplate<OPimEvent> {
 public:
     ODateBookAccess( ODateBookAccessBackend* = 0l, enum Access acc = Random );
     ~ODateBookAccess();
 
     /* return all events */
     List rawEvents()const;
 
     /* return repeating events */
     List rawRepeats()const;
 
     /* return non repeating events */
     List nonRepeats()const;
 
     /* return non repeating events (from,to) */
     OEffectiveEvent::ValueList effectiveEvents( const QDate& from, const QDate& to ) const;
     OEffectiveEvent::ValueList effectiveEvents( const QDateTime& start ) const;
     OEffectiveEvent::ValueList effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const;
     OEffectiveEvent::ValueList effectiveNonRepeatingEvents( const QDateTime& start ) const;
 
+    /** 
+     * Return identification of used records
+     */
+    int rtti() const;
+
+
 private:
     ODateBookAccessBackend* m_backEnd;
     class Private;
     Private* d;
 };
 
 }
 
 #endif
diff --git a/libopie2/opiepim/core/opimaccesstemplate.h b/libopie2/opiepim/core/opimaccesstemplate.h
index f1bcc44..d4c5fbb 100644
--- a/libopie2/opiepim/core/opimaccesstemplate.h
+++ b/libopie2/opiepim/core/opimaccesstemplate.h
@@ -1,27 +1,28 @@
 /*
                              This file is part of the Opie Project
-                             Copyright (C) The Main Author <main-author@whereever.org>
+                             Copyright (C) Holger Freyther <zecke@handhelds.org>
+			     Copyright (C) Stefan Eilers <eilers.stefan@epost.de>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
@@ -116,48 +117,55 @@ public:
     /**
      * 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() ;
 
     /**
      * add T to the backend
      * @param t The item to add.
      * @return <i>true</i> if added successfully.
      */
     virtual bool add( const T& t ) ;
     bool add( const OPimRecord& );
+    // Needed for real generic access (eilers) 
+    // Info: Take this if  you are working with OPimRecord, which is a generic base class, and 
+    //       you need to add it into any database, you cannot generate a reference to
+    //       it and casting may be not approriate, too. 
+    //       But take care that the accessing database is compatible to the real type of OPimRecord !!
+    bool add( const OPimRecord* );
+
 
     /* 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.
      */
     bool remove( int uid );
     bool remove( const OPimRecord& );
 
     /**
      * replace T from backend
      * @param t The item to replace
      * @return <i>true</i> if successful.
      */
     virtual bool replace( const T& t) ;
 
@@ -250,57 +258,71 @@ T OPimAccessTemplate<T>::find( int uid, const QArray<int>& ar,
     /*
      * better do T.isEmpty()
      * after a find this way we would
      * avoid two finds in QCache...
      */
     // qWarning("find it now %d", uid );
     if (m_cache.contains( uid ) ) {
         return m_cache.find( uid );
     }
 
     T t = m_backEnd->find( uid, ar, current, dir );
     cache( t );
     return t;
 }
 template <class T>
 void OPimAccessTemplate<T>::clear() {
     invalidateCache();
     m_backEnd->clear();
 }
 template <class T>
 bool OPimAccessTemplate<T>::add( const T& t ) {
     cache( t );
     return m_backEnd->add( t );
 }
+
 template <class T>
 bool OPimAccessTemplate<T>::add( const OPimRecord& rec) {
     /* same type */
-    if ( rec.rtti() == T::rtti() ) {
+    T tempInstance;
+    if ( rec.rtti() == tempInstance.rtti() ) {
         const T &t = static_cast<const T&>(rec);
         return add(t);
     }
     return false;
 }
+
+template <class T>
+bool OPimAccessTemplate<T>::add( const OPimRecord* rec) {
+    /* same type, but pointer  */
+    T tempInstance;
+    if ( rec -> rtti() == tempInstance.rtti() ) {
+        const T* t = static_cast<const T*>(rec);
+        return add( *t );
+    }
+    return false;
+}
+
 template <class T>
 bool OPimAccessTemplate<T>::remove( const T& t ) {
     return remove( t.uid() );
 }
 template <class T>
 bool OPimAccessTemplate<T>::remove( int uid ) {
     m_cache.remove( uid );
     return m_backEnd->remove( uid );
 }
 template <class T>
 bool OPimAccessTemplate<T>::remove( const OPimRecord& rec) {
     return remove( rec.uid() );
 }
 template <class T>
 bool OPimAccessTemplate<T>::replace( const T& t ) {
     m_cache.replace( t );
     return m_backEnd->replace( t );
 }
 template <class T>
 void OPimAccessTemplate<T>::invalidateCache() {
     m_cache.invalidate();
 }
 template <class T>
 typename OPimAccessTemplate<T>::BackEnd* OPimAccessTemplate<T>::backEnd() {
diff --git a/libopie2/opiepim/core/opimtemplatebase.h b/libopie2/opiepim/core/opimtemplatebase.h
index 58cbfeb..b48dfed 100644
--- a/libopie2/opiepim/core/opimtemplatebase.h
+++ b/libopie2/opiepim/core/opimtemplatebase.h
@@ -1,130 +1,122 @@
 /*
                              This file is part of the Opie Project
-                             Copyright (C) The Main Author <main-author@whereever.org>
+                             Copyright (C) Holger Freyther <zecke@handhelds.org>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OTEMPLATEBASE_H
 #define OTEMPLATEBASE_H
 
 /* OPIE */
 #include <opie2/opimrecord.h>
 
 /* QT */
 #include <qarray.h>
 
 namespace Opie {
 /**
  * Templates do not have a base class, This is why
  * we've this class
  * this is here to give us the possibility
  * to have a common base class
  * You may not want to use that interface internaly
  * POOR mans interface
  */
 class OPimBasePrivate;
 struct OPimBase {
     /**
      * return the rtti
      */
-    virtual int rtti()= 0;
+    virtual int rtti() const = 0;
     virtual OPimRecord* record()const = 0;
     virtual OPimRecord* record(int uid)const = 0;
     virtual bool add( const OPimRecord& ) = 0;
+    virtual bool add( const OPimRecord* ) = 0;
     virtual bool remove( int uid ) = 0;
     virtual bool remove( const OPimRecord& ) = 0;
     virtual void clear() = 0;
     virtual bool load() = 0;
     virtual bool save() = 0;
     virtual QArray<int> records()const = 0;
     /*
      * ADD editing here?
      * -zecke
      */
 private:
     OPimBasePrivate* d;     
 
 };
 /**
  * internal template base
  * T needs to implement the copy c'tor!!!
  */
 class OTemplateBasePrivate;
 template <class T = OPimRecord>
 class OTemplateBase : public OPimBase {
 public:
     enum CacheDirection { Forward=0, Reverse };
     OTemplateBase() {
     };
     virtual ~OTemplateBase() {
     }
     virtual T find( int uid )const = 0;
 
     /**
      * read ahead find
      */
     virtual T find( int uid, const QArray<int>& items,
                     uint current, CacheDirection dir = Forward )const = 0;
     virtual void cache( const T& )const = 0;
     virtual void setSaneCacheSize( int ) = 0;
 
-    /* reimplement of OPimBase */
-    int rtti();
     OPimRecord* record()const;
     OPimRecord* record(int uid )const;
     static T* rec();
     
 private:
     OTemplateBasePrivate *d;    
 };
 
-/*
- * implementation
- */
-template <class T>
-int
-OTemplateBase<T>::rtti() {
-    return T::rtti();
-}
+
 template <class T>
 OPimRecord* OTemplateBase<T>::record()const {
     T* t = new T;
     return t;
 }
 template <class T>
 OPimRecord* OTemplateBase<T>::record(int uid )const {
     T  t2 = find(uid );
     T* t1 = new T(t2);
 
     return t1;
 };
 template <class T>
 T* OTemplateBase<T>::rec() {
     return new T;
 }
 
 }
 
 #endif
diff --git a/libopie2/opiepim/core/otodoaccess.cpp b/libopie2/opiepim/core/otodoaccess.cpp
index 83750d5..6fa0089 100644
--- a/libopie2/opiepim/core/otodoaccess.cpp
+++ b/libopie2/opiepim/core/otodoaccess.cpp
@@ -12,48 +12,49 @@
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 #include <qdatetime.h>
 
 #include <qpe/alarmserver.h>
 
 // #include "otodoaccesssql.h"
 #include <opie2/otodoaccess.h>
 #include <opie2/obackendfactory.h>
+#include <opie2/opimresolver.h>
 
 namespace Opie {
 OPimTodoAccess::OPimTodoAccess( OPimTodoAccessBackend* end, enum Access )
     : QObject(), OPimAccessTemplate<OPimTodo>( end ),  m_todoBackEnd( end )
 {
 //     if (end == 0l )
 //         m_todoBackEnd = new OPimTodoAccessBackendSQL( QString::null);
 
 	// Zecke: Du musst hier noch fr das XML-Backend einen Appnamen bergeben !
         if (end == 0l )
 		m_todoBackEnd = OBackendFactory<OPimTodoAccessBackend>::Default ("todo", QString::null);
 
     setBackEnd( m_todoBackEnd );
 }
 OPimTodoAccess::~OPimTodoAccess() {
 //    qWarning("~OPimTodoAccess");
 }
 void OPimTodoAccess::mergeWith( const QValueList<OPimTodo>& list ) {
     QValueList<OPimTodo>::ConstIterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         replace( (*it) );
     }
 }
 OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start,
@@ -69,25 +70,31 @@ OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start,
     return effectiveToDos( start, QDate::currentDate(),
                            includeNoDates );
 }
 OPimTodoAccess::List OPimTodoAccess::overDue() {
     List lis( m_todoBackEnd->overDue(), this );
     return lis;
 }
 /* sort order */
 OPimTodoAccess::List OPimTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) {
     QArray<int> ints = m_todoBackEnd->sorted( ascending, sort,
                                       filter, cat );
     OPimTodoAccess::List list( ints, this );
     return list;
 }
 void OPimTodoAccess::removeAllCompleted() {
     m_todoBackEnd->removeAllCompleted();
 }
 QBitArray OPimTodoAccess::backendSupport( const QString& ) const{
     return m_todoBackEnd->supports();
 }
 bool OPimTodoAccess::backendSupports( int attr,  const QString& ar) const{
     return backendSupport(ar).testBit( attr );
 }
 
+
+int OPimTodoAccess::rtti() const
+{
+	return OPimResolver::TodoList;
+}
+
 }
diff --git a/libopie2/opiepim/core/otodoaccess.h b/libopie2/opiepim/core/otodoaccess.h
index 51f3793..3f5af30 100644
--- a/libopie2/opiepim/core/otodoaccess.h
+++ b/libopie2/opiepim/core/otodoaccess.h
@@ -95,42 +95,48 @@ public:
      * the resource
      */
     void mergeWith( const QValueList<OPimTodo>& );
 
     /**
      * delete all already completed items
      */
     void removeAllCompleted();
 
     /**
      * request information about what a backend supports.
      * Supports in the sense of beeing able to store.
      * This is related to the enum in OPimTodo
      *
      * @param backend Will be used in the future when we support multiple backend
      */
     QBitArray backendSupport( const QString& backend = QString::null )const;
 
     /**
      * see above but for a specefic attribute. This method was added for convience
      * @param attr The attribute to be queried for
      * @param backend Will be used in the future when we support multiple backends
      */
     bool backendSupports( int attr, const QString& backend = QString::null  )const;
+
+
+    /** 
+     * Return identification of used records
+     */
+    int rtti() const;
 signals:
     /**
      * if the OPimTodoAccess was changed
      */
     void changed( const OPimTodoAccess* );
     void changed( const OPimTodoAccess*, int uid );
     void added( const OPimTodoAccess*,  int uid );
     void removed( const OPimTodoAccess*, int uid );
 private:
     int m_cat;
     OPimTodoAccessBackend* m_todoBackEnd;
     class OPimTodoAccessPrivate;
     OPimTodoAccessPrivate* d;
 };
 
 }
 
 #endif