Sync.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 SYNC_HPP_
#define SYNC_HPP_

#include <map>
#include <string>
#include <vector>
#include <plugin/Plugin.hpp>
#include <plugin/GenericParameters.hpp>
#include <plugin/source/Source.hpp>
#include <plugin/storage/Storage.hpp>

namespace OpenAB_Sync {

class Parameters : public OpenAB_Plugin::GenericParameters
{
  public:
    Parameters();

    Parameters(const std::string& json);

    ~Parameters();

    OpenAB_Source::Parameters localSourcePluginParams;

    OpenAB_Source::Parameters remoteSourcePluginParams;

    OpenAB_Storage::Parameters localStoragePluginParams;

    OpenAB_Storage::Parameters remoteStoragePluginParams;
};

class Sync
{
  public:
    Sync(){}

    virtual ~Sync(){}

    enum eInit{
      eInitOk,    
      eInitFail   
    };

    virtual enum eInit init() = 0;

    enum eSync{
      eSyncOkWithDataChange,    
      eSyncOkWithoutDataChange, 
      eSyncCancelled,           
      eSyncAlreadyInProgress,   
      eSyncFail                 
    };

    virtual void synchronize() = 0;

    enum eCancel {
      eCancelOk,
      eCancelNotInProgress,
      eCancelFail
    };

    virtual enum eCancel cancel() = 0;

    enum eSuspend {
      eSuspendOk,
      eSuspendNotInProgress,
      eSuspendFail
    };

    virtual enum eSuspend suspend() = 0;

    enum eResume {
      eResumeOk,
      eResumeNotSuspended,
      eResumeFail
    };

    virtual enum eResume resume() = 0;

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

    bool addPhase(const std::string& name, const std::vector<std::string>& ignoreFields);

    void clearPhases();

    class SyncCallback
    {
      public:
        SyncCallback(){};
        virtual ~SyncCallback(){};
        virtual void print(const std::string& msg) = 0;

        virtual void syncFinished(const enum OpenAB_Sync::Sync::eSync& result) = 0;

        virtual void syncProgress(const std::string& phaseName, double progress, unsigned int numProcessedItems) = 0;

        virtual void syncPhaseStarted(const std::string& name) = 0;

        virtual void syncPhaseFinished(const std::string& name) = 0;

        virtual void metadataUpdated(const std::string& ){}
    };

  protected:
    struct Phase
    {
      Phase(const std::string& n, const std::vector<std::string> & ignore) :
        name(n),
        ignoredFields(ignore) {}

      std::string name;
      std::vector<std::string> ignoredFields;
    };
    std::vector<Phase> phases;

  private:
    Sync(Sync const &other);

    Sync& operator=(Sync const &other);
};

//typedef OpenAB_Plugin::Factory< Sync , Parameters > Factory;

class SyncMetadata
{
  public:
    SyncMetadata();
    ~SyncMetadata();

    void addItem(const std::string& remoteId, const std::string& remoteRevision,
                 const std::string& localId, const std::string& localRevision);

    void removeItem(const std::string& remoteId, const std::string& localId);

    void updateRemoteRevision(const std::string& uid, const std::string& revision);

    void updateLocalRevision(const std::string& uid, const std::string& revision);

    std::string getRemoteRevision(const std::string& uid) const;

    std::string getLocalRevision(const std::string& uid) const;

    bool hasLocalId(const std::string& uid) const;

    bool hasRemoteId(const std::string& uid) const;

    std::string toJSON() const;

    bool fromJSON(const std::string& json);

    enum SyncMetadataState {
      NotPresent= 0,  
      NotChanged,     
      Modified        
    };


    void resetRemoteState(SyncMetadataState st);

    void resetLocalState(SyncMetadataState st);

    void setRemoteState(const std::string& uid, SyncMetadataState state);

    void setLocalState(const std::string& uid, SyncMetadataState state);

    std::map<std::string, std::string> getItemsWithState(SyncMetadataState localState, SyncMetadataState remoteState);

    std::string getLocalSyncToken() const;
 
    void setLocalSyncToken(const std::string& token);

    std::string getRemoteSyncToken() const;

    void setRemoteSyncToken(const std::string& token);

  private:
    std::string remoteSyncToken;
    std::string localSyncToken;
    std::map<std::string, std::string> remoteRevisions;
    std::map<std::string, std::string> localRevisions;
    std::map<std::string, std::string> remoteToLocalIdMapping;

    std::map<std::string, SyncMetadataState> remoteState;
    std::map<std::string, SyncMetadataState> localState;
};
} // namespace OpenAB_Sync

DECLARE_PLUGIN_INTERFACE(OpenAB_Sync, Sync, Parameters);

#endif // SYNC_HPP_