1 files changed, 21 insertions, 6 deletions

diff --git a/libopie/pim/opimaccesstemplate.h b/libopie/pim/opimaccesstemplate.h
index 3e1f393..50cb1e4 100644
--- a/libopie/pim/opimaccesstemplate.h
+++ b/libopie/pim/opimaccesstemplate.h
@@ -24,94 +24,108 @@ class OPimAccessTemplate : public OTemplateBase<T> {
 public:
     typedef ORecordList<T> List;
     typedef OPimAccessBackend<T> BackEnd;
     typedef OPimCache<T> Cache;
 
     /**
      * c'tor BackEnd
      */
     OPimAccessTemplate( BackEnd* end);
     virtual ~OPimAccessTemplate();
 
     /**
      * load from the backend
      */
     virtual bool load();
 
-    /**
-     * reload from the backend
+    /** Reload database.
+     * You should execute this function if the external database
+     * 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 to the backend
+    /** 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.
+     * @return <i>true</i> if added successfully.
      */
     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) ;
 
     /**
      * @internal
      */
     void cache( const T& )const;
     void setSaneCacheSize( int );
 protected:
     /**
      * invalidate the cache
      */
     void invalidateCache();
 
     void setBackEnd( BackEnd* end );
     /**
@@ -129,33 +143,34 @@ OPimAccessTemplate<T>::OPimAccessTemplate( BackEnd* end )
 {
     if (end )
         end->setFrontend( this );
 }
 template <class T>
 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() {
-    return m_backEnd->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>
 OPimAccessTemplate<T>::List OPimAccessTemplate<T>::allRecords()const {
     QArray<int> ints = m_backEnd->allRecords();
     List lis(ints, this );
     return lis;
 }
 template <class T>
 OPimAccessTemplate<T>::List
 OPimAccessTemplate<T>::queryByExample( const T& t, int sortOrder ) {
     QArray<int> ints = m_backEnd->queryByExample( t, sortOrder );