Diffstat (limited to 'noncore/unsupported/libopie/pim/opimaccesstemplate.h') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | noncore/unsupported/libopie/pim/opimaccesstemplate.h | 302 |
1 files changed, 302 insertions, 0 deletions
diff --git a/noncore/unsupported/libopie/pim/opimaccesstemplate.h b/noncore/unsupported/libopie/pim/opimaccesstemplate.h new file mode 100644 index 0000000..ecbeb68 --- a/dev/null +++ b/noncore/unsupported/libopie/pim/opimaccesstemplate.h @@ -0,0 +1,302 @@ +#ifndef OPIE_PIM_ACCESS_TEMPLATE_H +#define OPIE_PIM_ACCESS_TEMPLATE_H + +#include <qarray.h> + +#include <opie/opimrecord.h> +#include <opie/opimaccessbackend.h> +#include <opie/orecordlist.h> + +#include "opimcache.h" +#include "otemplatebase.h" + +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 + */ + +template <class T = OPimRecord > +class OPimAccessTemplate : public OTemplateBase<T> { +public: + enum Access { + Random = 0, + SortedAccess + }; + typedef ORecordList<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; + + /** + * 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& ); + + /* 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> +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() ) { + 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() { + 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 |