kitchensync Library API Documentation

incidencetemplate.h

00001 /*
00002     This file is part of KitchenSync.
00003 
00004     Copyright (c) 2002 Holger Freyther <zecke@handhelds.org>
00005 
00006     This library is free software; you can redistribute it and/or
00007     modify it under the terms of the GNU Library General Public
00008     License as published by the Free Software Foundation; either
00009     version 2 of the License, or (at your option) any later version.
00010 
00011     This library is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014     Library General Public License for more details.
00015 
00016     You should have received a copy of the GNU Library General Public License
00017     along with this library; see the file COPYING.LIB.  If not, write to
00018     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00019     Boston, MA 02111-1307, USA.
00020 */
00021 #ifndef KSYNC_INCEDENCE_TEMPLATE_H
00022 #define KSYNC_INCEDENCE_TEMPLATE_H
00023 
00024 #include "syncee.h"
00025 
00026 #include <qmap.h>
00027 
00028 #include <libkcal/incidence.h>
00029 
00030 /*
00031  * Internal helper!!!
00032  */
00033 
00034 namespace KSync {
00035     template <class Entry = KCal::Incidence>
00036     class IncidenceTemplate : public SyncEntry {
00037     public:
00038         typedef QPtrList<Entry> PtrList;
00039         IncidenceTemplate( Entry *entry, Syncee *parent )
00040             : SyncEntry( parent ), mIncidence( entry ) {
00041             if (!entry )
00042                 mIncidence = new Entry;
00043 
00044         };
00045         IncidenceTemplate( const IncidenceTemplate& temp )
00046             : SyncEntry( temp ){
00047             mIncidence = (Entry*)temp.mIncidence->clone();
00048 
00049         }
00050         ~IncidenceTemplate() {
00051             delete mIncidence;
00052         }
00053         QString type() const { return mIncidence->type() + "SyncEntry"; }
00054         QString name() { return mIncidence->summary(); }
00055         QString id() { return mIncidence->uid(); }
00056         void setId(const QString& id) { mIncidence->setUid( id ); }
00057         QString timestamp() { return mIncidence->lastModified().toString(); }
00058         Entry* incidence() { return mIncidence; };
00059         bool equals( SyncEntry* entry) {
00060             IncidenceTemplate* inEntry = dynamic_cast<IncidenceTemplate*> (entry );
00061             if (!inEntry )
00062                 return false;
00063             if (mIncidence->uid() != inEntry->incidence()->uid() ) return false;
00064             if (mIncidence->lastModified() != inEntry->incidence()->lastModified() )
00065                 return false;
00066 
00067             return true;
00068         }
00069         SyncEntry* clone() {
00070             return new IncidenceTemplate<Entry>( *this );
00071         }
00072     private:
00073         Entry* mIncidence;
00074 
00075     };
00076    /*
00077     * common support map!!!
00078     */
00079     namespace Cal {
00080     template<class T> void mergeOrg( T* const, const T* const );
00081     template<class T> void mergeRead( T* const, const T* const );
00082     template<class T> void mergedtStart( T* const, const T* const );
00083     template<class T> void mergeDur( T* const, const T* const );
00084     template<class T> void mergeFloat( T* const, const T* const );
00085     template<class T> void mergeAttend( T* const, const T* const );
00086     template<class T> void mergeCreated( T* const, const T* const );
00087     template<class T> void mergeRev( T* const, const T* const );
00088     template<class T> void mergeDes( T* const, const T* const );
00089     template<class T> void mergeSum( T* const, const T* const );
00090     template<class T> void mergeCat( T* const, const T* const );
00091     template<class T> void mergeRel( T* const, const T* const );
00092     template<class T> void mergeExDates( T* const, const T* const );
00093     template<class T> void mergeAtt( T* const, const T* const );
00094     template<class T> void mergeSec( T* const,  const T* const );
00095     template<class T> void mergeRes( T* const,  const T* const );
00096     template<class T> void mergePrio( T* const, const T* const );
00097     template<class T> void mergeAlarm( T* const, const T* const );
00098     template<class T> void mergeRecur( T* const, const T* const );
00099     template<class T> void mergeLoc( T* const, const T* const );
00100     }
00101 
00102     template <class T,  class U>
00103     class MergeBase {
00104     public:
00105         MergeBase();
00106         virtual ~MergeBase();
00107         typedef void (*merge)(T* const, const T* const );
00108         typedef QMap<int, merge> MergeMap;
00109         typedef typename QMap<int, merge>::Iterator Iterator;
00110         void invoke( int, T* const, const T* const );
00111         void add( int, merge );
00112     protected:
00113         MergeMap map;
00114     };
00115 
00116     // Implementation
00117 
00118     // add the functions to the map
00119     template <class T, class U> MergeBase<T, U>::MergeBase() {
00120         map.insert( U::Organizer,  Cal::mergeOrg );
00121         map.insert( U::ReadOnly,  Cal::mergeRead );
00122         map.insert( U::DtStart,  Cal::mergedtStart );
00123         map.insert( U::Duration,  Cal::mergeDur );
00124         map.insert( U::Float,  Cal::mergeFloat );
00125         map.insert( U::Attendee,  Cal::mergeAttend );
00126         map.insert( U::CreatedDate,   Cal::mergeCreated );
00127         map.insert( U::Revision,  Cal::mergeRev );
00128         map.insert( U::Description,  Cal::mergeDes );
00129         map.insert( U::Summary,  Cal::mergeSum );
00130         map.insert( U::Category, Cal::mergeCat );
00131         map.insert( U::Relations,  Cal::mergeRel );
00132         map.insert( U::ExDates,  Cal::mergeExDates );
00133         map.insert( U::Attachments,  Cal::mergeAtt );
00134         map.insert( U::Secrecy,  Cal::mergeSec );
00135         map.insert( U::Resources,  Cal::mergeRes );
00136         map.insert( U::Priority,  Cal::mergePrio );
00137         map.insert( U::Alarms,  Cal::mergeAlarm );
00138         map.insert( U::Recurrence,  Cal::mergeRecur );
00139         map.insert( U::Location,  Cal::mergeLoc );
00140     }
00141     template <class T,  class U> MergeBase<T, U>::~MergeBase() {
00142     }
00143     template <class T,  class U> void MergeBase<T, U>::invoke(int i, T* const dest, const T* const src) {
00144         Iterator it= map.find( i );
00145         if ( it != map.end() )
00146             (*it.data())(dest, src );
00147     }
00148     template<class T, class U>
00149     void MergeBase<T, U>::add(int res, merge mer ) {
00150         map.insert( res, mer );
00151     }
00152 
00153     namespace Cal {
00154     // implementation of the merge functions
00155     template <class Todo> void mergeOrg( Todo* const dest, const Todo* const src) {
00156         dest->setOrganizer( src->organizer() );
00157     }
00158     template <class Todo> void mergeRead( Todo* const dest, const Todo* const src) {
00159         dest->setReadOnly( src->isReadOnly() );
00160     }
00161     template <class Todo> void mergedtStart( Todo* const dest, const Todo* const src) {
00162         dest->setDtStart( src->dtStart() );
00163     }
00164     template <class Todo> void mergeDur( Todo* const dest, const Todo* const src) {
00165         dest->setDuration( src->duration() );
00166     }
00167     template <class Todo> void mergeFloat( Todo* const dest, const Todo* const src) {
00168         dest->setFloats( src->doesFloat() );
00169     }
00170     template <class Todo>  void mergeAttend( Todo* const dest, const Todo* const src) {
00171         KCal::Attendee::List att = src->attendees();
00172         KCal::Attendee::List::ConstIterator it;
00173         for ( it = att.begin(); it != att.end(); ++it )
00174             dest->addAttendee( new KCal::Attendee( **it ) );
00175     }
00176     template <class Todo>  void mergeCreated( Todo* const dest, const Todo* const src) {
00177         dest->setCreated( src->created() );
00178     }
00179     template <class Todo> void mergeRev( Todo* const dest, const Todo* const src) {
00180         dest->setRevision( src->revision() );
00181     }
00182     template <class Todo> void mergeDes( Todo* const dest, const Todo* const src) {
00183         dest->setDescription( src->description() );
00184     }
00185     template <class Todo> void mergeSum( Todo* const dest, const Todo* const src) {
00186         dest->setSummary( src->summary() );
00187     }
00188     template <class Todo> void mergeCat( Todo* const dest, const Todo* const src) {
00189         dest->setCategories( src->categories() );
00190     }
00191     template <class Todo> void mergeRel( Todo* const dest, const Todo* const src) {
00192         KCal::Incidence::List rel = src->relations();
00193         KCal::Incidence::List::ConstIterator it;
00194         for ( it = rel.begin(); it != rel.end(); ++it ) {
00195             dest->addRelation( (*it)->clone() );
00196         }
00197     }
00198     template <class Todo> void mergeExDates( Todo* const dest, const Todo* const src) {
00199         dest->setExDates( src->exDates() );
00200     }
00201     template <class Todo> void mergeAtt( Todo* const, const Todo* const ) {
00202     // FIXME!!!
00203     }
00204     template <class Todo> void mergeSec( Todo* const dest,  const Todo* const src) {
00205         dest->setSecrecy( src->secrecy() );
00206     }
00207     template <class Todo> void mergeRes( Todo* const dest,  const Todo* const src) {
00208         dest->setResources( src->resources() );
00209     }
00210     template <class Todo> void mergePrio( Todo* const dest, const Todo* const src) {
00211         dest->setPriority( src->priority() );
00212     }
00213     template <class Todo> void mergeAlarm( Todo* const dest, const Todo* const src ) {
00214         KCal::Alarm::List als = src->alarms();
00215         KCal::Alarm::List::ConstIterator it;
00216         for ( it = als.begin(); it != als.end(); ++it ) {
00217             dest->addAlarm( new KCal::Alarm( **it ) );
00218         }
00219     }
00220     template <class Todo> void mergeRecur( Todo* const , const Todo* const ) {
00221          // not available
00222     }
00223     template <class Todo> void mergeLoc( Todo* const dest , const Todo* const src) {
00224         dest->setLocation( src->location() );
00225     }
00226     }
00227 }
00228 
00229 
00230 #endif
KDE Logo
This file is part of the documentation for kitchensync Library Version 3.3.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Aug 23 18:20:08 2007 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003