Fix comment

s/plugins/template

1 files changed, 7 insertions, 7 deletions

diff --git a/libopie2/opiepim/core/opimaccesstemplate.h b/libopie2/opiepim/core/opimaccesstemplate.h
index d4c5fbb..e438980 100644
--- a/libopie2/opiepim/core/opimaccesstemplate.h
+++ b/libopie2/opiepim/core/opimaccesstemplate.h
@@ -1,272 +1,272 @@
 /*
                              This file is part of the Opie Project
                              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.
 */
 #ifndef OPIE_PIM_ACCESS_TEMPLATE_H
 #define OPIE_PIM_ACCESS_TEMPLATE_H
 
 #include <qarray.h>
 
 #include <opie2/opimrecord.h>
 #include <opie2/opimaccessbackend.h>
 #include <opie2/opimrecordlist.h>
 
 #include <opie2/opimcache.h>
 #include <opie2/opimtemplatebase.h>
 
 namespace Opie {
 
 class OPimAccessTemplatePrivate;
 /**
  * Thats the frontend to our OPIE PIM
  * Library. Either you want to use it's
  * interface or you want to implement
  * your own Access lib
  * Just create a OPimRecord and inherit from
- * the plugins
+ * the templates
  */
 
 template <class T = OPimRecord >
 class OPimAccessTemplate : public OTemplateBase<T> {
 public:
     enum Access {
         Random = 0,
         SortedAccess
     };
     typedef OPimRecordList<T> List;
     typedef OPimAccessBackend<T> BackEnd;
     typedef OPimCache<T> Cache;
 
     /**
      * c'tor BackEnd
      * enum Access a small hint on how to handle the backend
      */
     OPimAccessTemplate( BackEnd* end);
 
     virtual ~OPimAccessTemplate();
 
     /**
      * load from the backend
      */
     bool load();
 
     /** 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 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;   
+    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() ;
 
     /**
      * 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 
+    // 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. 
+    //       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) ;
 
     void setReadAhead( uint count );
     /**
      * @internal
      */
     void cache( const T& )const;
     void setSaneCacheSize( int );
 
     QArray<int> records()const;
 protected:
     /**
      * invalidate the cache
      */
     void invalidateCache();
 
     void setBackEnd( BackEnd* end );
     /**
      * returns the backend
      */
     BackEnd* backEnd();
     BackEnd* m_backEnd;
     Cache m_cache;
 
 private:
     OPimAccessTemplatePrivate *d;
 
 };
 
 template <class T>
 OPimAccessTemplate<T>::OPimAccessTemplate( BackEnd* end )
     : OTemplateBase<T>(), m_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() {
         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...
      */
     // 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>