OneWaySync.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef ONE_WAY_SYNC_HPP
#define ONE_WAY_SYNC_HPP


#include <pthread.h>
#include "plugin/sync/Sync.hpp"

struct OpenAB_Sync_params
{
    std::string                     input_plugin; 
    OpenAB_Source::Parameters          input_params; 
    std::string                     ab_plugin;    
    OpenAB_Storage::Parameters         ab_params;    
    OpenAB_Sync::Sync::SyncCallback *  cb;           
    enum SyncType
    {
      eSyncIncremental,
      eSyncAll,
      eSyncText
    }                               sync_type;
    float                           sync_progress_time;
    unsigned int                    batch_size;
};

class OneWaySync : public OpenAB_Sync::Sync
{
  public:
    OneWaySync(OpenAB_Sync_params&);
    ~OneWaySync();

    enum OpenAB_Sync::Sync::eInit init();

    void synchronize();

    enum OpenAB_Sync::Sync::eCancel cancel();

    enum OpenAB_Sync::Sync::eSuspend suspend();

    enum OpenAB_Sync::Sync::eResume resume();

    void getStats(unsigned int& locallyAdded,
                  unsigned int& locallyModified,
                  unsigned int& locallyRemoved,
                  unsigned int& remotelyAdded,
                  unsigned int& remotelyModified,
                  unsigned int& remotelyRemoved);

  private:
    OneWaySync(OneWaySync const &other);

    OneWaySync& operator=(OneWaySync const &other);

    void updateIndexDB();
    void processItems(unsigned int phaseNum);
    void cleanStorage();

    void addItem(const OpenAB::SmartPtr<OpenAB::PIMItem> & item);
    void modifyItem(const std::string& id, const OpenAB::SmartPtr<OpenAB::PIMItem> & item);
    bool flushInsertions();
    bool flushModifications();

    enum eSync doSynchronize();
    static void* threadSync(void*);

    struct SyncStats {
        void clean(){
          added    = 0;
          modified = 0;
          removed  = 0;
        };
        unsigned int added;
        unsigned int modified;
        unsigned int removed;
        pthread_mutex_t mutex;

    };

    SyncStats phaseStats;
    SyncStats globalStats;

    OpenAB_Sync_params       params;

    OpenAB_Source::Source*   source;
    OpenAB_Storage::Storage* storage;

    typedef std::vector< OpenAB::SmartPtr<OpenAB_Storage::StorageItem> > vectorElem;
    typedef std::map< OpenAB::SmartPtr<OpenAB::PIMItemIndex> , vectorElem > dbIndexElem;
    dbIndexElem indexDB;

    struct ItemDesc
    {
        ItemDesc(const std::string& _id, OpenAB::SmartPtr<OpenAB::PIMItem> vcard) :
        id (_id),
        item (vcard){}

      std::string id;
      OpenAB::SmartPtr<OpenAB::PIMItem> item;
    };

    std::vector<ItemDesc> itemsToBeAdded;
    std::vector<ItemDesc> itemsToBeModified;

    bool dbError;
    bool inputError;

    pthread_t syncThread;
    pthread_mutex_t syncMutex;
    bool threadCreated;
    bool syncInProgress;
    eSync lastSyncResult;
    bool cancelSync;
};

#endif /* ONE_WAY_SYNC_HPP */