opimaccessbackend.h

Go to the documentation of this file.

/*
                             This file is part of the Opie Project
                             Copyright (C) The Main Author <main-author@whereever.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 OPIE_PIM_ACCESS_BACKEND
#define OPIE_PIM_ACCESS_BACKEND

#include <qarray.h>
#include <qdatetime.h>

#include <opie2/opimtemplatebase.h>
#include <opie2/opimrecord.h>
#include <opie2/opimbackendoccurrence.h>

namespace Opie {
class OPimAccessBackendPrivate;

template <class T = OPimRecord>
class OPimAccessBackend {
public:
    typedef OTemplateBase<T> Frontend;

    OPimAccessBackend(int access = 0);
    virtual ~OPimAccessBackend();

    virtual bool load() = 0;
    virtual bool reload() = 0;
    virtual bool save() = 0;
    virtual void clear() = 0;

    // FIXME: Uncommented some of the abstract functions below. This should be removed as they are implemented in 
    // all typespecifc backenends (eilers) 
    virtual const uint querySettings() const = 0;

    virtual bool hasQuerySettings (uint querySettings) const = 0;


    virtual UIDArray allRecords()const = 0;
    virtual UIDArray matchRegexp(const QRegExp &r) const;
    virtual UIDArray queryByExample( const UIDArray&, const T& t, 
                                     int settings, const QDateTime& d = QDateTime() )const = 0;
    virtual UIDArray queryByExample( const T& t, int settings, const QDateTime& d = QDateTime() )const;
    virtual UIDArray queryByExample( const OPimRecord* rec, int settings, const QDateTime& d = QDateTime() )const;
    virtual UIDArray sorted( const UIDArray&, bool asc, int sortOrder, int sortFilter,  const QArray<int>& cats )const = 0;
    virtual UIDArray sorted( bool asc, int sortOrder, int sortFilter, const QArray<int>& cats )const;
    virtual OPimBackendOccurrence::List occurrences( const QDate& start, const QDate& end)const;
    virtual OPimBackendOccurrence::List occurrences( const QDateTime& dt )const;


    virtual T find(UID uid )const  = 0;
    virtual T find(UID uid, const QArray<UID>& items,
                   uint current, typename Frontend::CacheDirection )const ;


    virtual bool add( const T& t ) = 0;
    virtual bool remove( UID uid ) = 0;
    virtual bool replace( const T& t ) = 0;



    void setFrontend( Frontend* front );

    void setReadAhead( uint count );
protected:
    int access()const;
    void cache( const T& t )const;
    void setSaneCacheSize( int );
    uint readAhead()const;

private:
    OPimAccessBackendPrivate *d;
    Frontend* m_front;
    uint m_read;
    int m_acc;

};

template <class T>
OPimAccessBackend<T>::OPimAccessBackend(int acc)
    : m_acc( acc )
{
    m_front = 0l;
    m_read = 20;
}
template <class T>
OPimAccessBackend<T>::~OPimAccessBackend() {

}

/*
 * Slow but default matchRegexp Implementation
 * Create a Big Enough QArray and then iterate
 * over all Records and matchRegexp them.
 * At the end we will resize the array to the actual
 * number of items
 */
template <class T>
UIDArray OPimAccessBackend<T>::matchRegexp( const QRegExp& reg )const {
    UIDArray all_rec = allRecords();
    UIDArray result( all_rec.count() );
    uint used_records = 0, all_rec_count = all_rec.count();

    for ( uint i = 0; i < all_rec_count; ++i )
        if (find( all_rec[i], all_rec, i, Frontend::Forward ).match( reg ) )
            result[used_records++] = all_rec[i];

    /* shrink to fit */
    result.resize( used_records );
    return result;
}

template <class T>
UIDArray OPimAccessBackend<T>::queryByExample( const T& rec, int settings,
                                               const QDateTime& datetime )const {

        return queryByExample( allRecords(), rec, settings, datetime );
}

template <class T>
UIDArray OPimAccessBackend<T>::queryByExample( const OPimRecord* rec, int settings,
                                               const QDateTime& datetime )const {
    T* tmp_rec = T::safeCast( rec );
    UIDArray ar;
    if ( tmp_rec )
        ar = queryByExample( *tmp_rec, settings, datetime );

    return ar;
}

template <class T>
UIDArray OPimAccessBackend<T>::sorted( bool asc, int order, int filter,
                                       const QArray<int>& cats )const {
    return sorted( allRecords(), asc, order, filter, cats );
}

template<class T>
OPimBackendOccurrence::List OPimAccessBackend<T>::occurrences( const QDate&,
                                                               const QDate& )const {
    return OPimBackendOccurrence::List();
}

template<class T>
OPimBackendOccurrence::List OPimAccessBackend<T>::occurrences( const QDateTime& dt )const {
    QDate date = dt.date();
    return occurrences( date, date );
}

template <class T>
void OPimAccessBackend<T>::setFrontend( Frontend* fr ) {
    m_front = fr;
}
template <class T>
void OPimAccessBackend<T>::cache( const T& t )const {
    if ( m_front )
        m_front->cache( t );
}

template <class T>
void OPimAccessBackend<T>::setSaneCacheSize( int size) {
    if ( m_front )
        m_front->setSaneCacheSize( size );
}
template <class T>
T OPimAccessBackend<T>::find( int uid, const QArray<int>&,
                              uint, typename Frontend::CacheDirection ) const{
    qDebug( "*** Lookahead feature not supported. Fallback to default find!!" );
    return find( uid );
}
template <class T>
void OPimAccessBackend<T>::setReadAhead( uint count ) {
    m_read = count;
}
template <class T>
uint OPimAccessBackend<T>::readAhead()const {
    return m_read;
}
template <class T>
int OPimAccessBackend<T>::access()const {
    return m_acc;
}

}

#endif

---