FieldSynchroManager.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/DataStore/FieldSynchroManager.h>

#include <fesa-core/DataStore/FieldValue.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Utilities/Lock.h>


namespace fesa
{

FieldSynchroManager* FieldSynchroManager::theInstance_ = NULL;

FieldSynchroManager::FieldSynchroManager()
{

}

FieldSynchroManager* FieldSynchroManager::getInstance()
{
    if (!theInstance_)
    {
        theInstance_ = new FieldSynchroManager();
    }
    return theInstance_;
}

void FieldSynchroManager::registerModifiedField(MultiplexingContext* pContext, DataStore* pDataStore,
                                                bool isShared, FieldValueBase* pFieldValue)
{
    Lock lock(mutex_);
    PairFieldValueShared pairFieldValueShared(pFieldValue, isShared);
    MapModifiedFields::iterator itModifiedFields = recentlyModifiedFields_.find(pContext);
    if (itModifiedFields != recentlyModifiedFields_.end())
    {
        MapDataStoreSetOfPairs::iterator itr = itModifiedFields->second.find(pDataStore);
        if (itr != itModifiedFields->second.end())
        {
            itr->second.insert(pairFieldValueShared);
        }
        else
        {
            (itModifiedFields->second)[pDataStore].insert(pairFieldValueShared);
        }
    }
    else
    {
        MapDataStoreSetOfPairs mapDataStoreSetOfPairs;
        mapDataStoreSetOfPairs[pDataStore].insert(pairFieldValueShared);
        recentlyModifiedFields_.insert(make_pair(pContext, mapDataStoreSetOfPairs));
    }
}

void FieldSynchroManager::commitModifiedFieldSynchronization(MultiplexingContext* context)
{
    /*
     * itModifiedFields->first = MultiplexingContext*
     * itModifiedFields->second = MapDataStoreSetOfPairs
     * itDataStore->first = DataStore*
     * itDataStore->second = SetPairFieldValueShared
     * itPairsFieldValueShared->first = FieldValue*
     * itPairsFieldValueShared->second = bool (isShared)
     */
    Lock lock(mutex_);
    MapModifiedFields::iterator itModifiedFields = recentlyModifiedFields_.find(context);
    if (itModifiedFields != recentlyModifiedFields_.end())
    {
        MapDataStoreSetOfPairs::iterator itDataStore(itModifiedFields->second.begin());

        for (; itDataStore != itModifiedFields->second.end(); ++itDataStore)
        {
            SetPairFieldValueShared::iterator itPairFieldValueShared(itDataStore->second.begin());
            for (; itPairFieldValueShared != itDataStore->second.end(); ++itPairFieldValueShared)
            {
                if(itPairFieldValueShared->second) {// shared = true
                    itPairFieldValueShared->first->setToBeSync(true);
                }
                else // Field not shared needs to be comitted immediately
                    itPairFieldValueShared->first->commit(true);
            }
        }
        recentlyModifiedFields_.erase(itModifiedFields);
    }
}

void FieldSynchroManager::abortModifiedFieldSynchronization(MultiplexingContext* context)
{
    /*
     * itModifiedFields->first = MultiplexingContext*
     * itModifiedFields->second = MapDataStoreSetOfPairs
     * itDataStore->first = DataStore*
     * itDataStore->second = SetPairFieldValueShared
     * itPairsFieldValueShared->first = FieldValue*
     * itPairsFieldValueShared->second = bool (isShared)
     */
    Lock lock(mutex_);
    MapModifiedFields::iterator itModifiedFields = recentlyModifiedFields_.find(context);
    if (itModifiedFields != recentlyModifiedFields_.end())
    {
        MapDataStoreSetOfPairs::iterator itDataStore(itModifiedFields->second.begin());

        for (; itDataStore != itModifiedFields->second.end(); ++itDataStore)
        {
            //                itDataStore->first->lock();
            SetPairFieldValueShared::iterator itPairFieldValueShared(itDataStore->second.begin());
            for (; itPairFieldValueShared != itDataStore->second.end(); ++itPairFieldValueShared)
            {
                itPairFieldValueShared->first->setPendingChanged(false);
            }
            //                itDataStore->first->unlock();
        }
        recentlyModifiedFields_.erase(itModifiedFields);
    }
}

void FieldSynchroManager::commitModifiedFieldSynchronization()
{
    Lock lock(mutex_);
    MapModifiedFields::iterator itModifiedFields = recentlyModifiedFields_.begin();
    for (; itModifiedFields != recentlyModifiedFields_.end(); ++itModifiedFields)
    {
        MapDataStoreSetOfPairs::iterator itDataStore(itModifiedFields->second.begin());

        for (; itDataStore != itModifiedFields->second.end(); ++itDataStore)
        {
            SetPairFieldValueShared::iterator itPairFieldValueShared(itDataStore->second.begin());
            for (; itPairFieldValueShared != itDataStore->second.end(); ++itPairFieldValueShared)
            {
                if(itPairFieldValueShared->second)
                {
                    // shared = true
                    itPairFieldValueShared->first->setToBeSync(true);
                }
                else
                {
                    // Field not shared needs to be comitted immediately
                    itPairFieldValueShared->first->commit(true);
                }
            }
        }
        recentlyModifiedFields_.erase(itModifiedFields);
    }
}

} // fesa