AbstractField.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/DataStore/DataStore.h>
#include <fesa-core/DataStore/FieldValue.h>
#include <fesa-core/DataStore/FieldSynchroManager.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Synchronization/AbstractMultiplexingManager.h>
#include <fesa-core/Synchronization/ExtendedMultiplexingManager.h>
#include <fesa-core/Synchronization/CycleDescriptor.h>
#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/Exception/FesaException.h>


namespace fesa
{

AbstractField::AbstractField(const std::string& fieldName,
                             const FieldCategory fieldCategory, bool multiplexed,
                             bool multiMultiplexed, bool persistent, DataIntegrity bufferType,
                             DataStore* pDataStore) :
    name_(fieldName), fieldCategory_(fieldCategory), multiplexed_(multiplexed),
    multiplexingManager_(0), pDataStore_(pDataStore), isMultiMux_(
        multiMultiplexed), isPersistent_(persistent), isShared_(true),
    valueSize_(0), buffer_(bufferType) {
    // Attach the field to its parent: the device
    pDataStore_->registerField(this);
}

std::string AbstractField::getAsString(MultiplexingContext* context) {
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && (context == NULL || context->getType() == MultiplexingContext::NoneCtxt) )
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    std::string str("");
    getValueToStore(slot, str);
    return str;
}

void AbstractField::setMultiplexingManager(
    AbstractMultiplexingManager* muxManager) {
    multiplexingManager_ = muxManager;
}

AbstractMultiplexingManager* AbstractField::getMultiplexingManager() {
    return multiplexingManager_;
}

uint32_t AbstractField::getMuxDepth() {
    if (multiplexingManager_) {
        return multiplexingManager_->getDepth();
    }
    return 1;
}

void AbstractField::setMultiplexed(bool multiplexed) {
    multiplexed_ = multiplexed;
}

bool AbstractField::isMultiplexed() {
    return multiplexed_;

}

const std::string& AbstractField::getName() {
    return name_;
}

bool AbstractField::isPersistent() {
    return isPersistent_;
}

void AbstractField::setMultiMuxFlag(bool flag) {
    isMultiMux_ = flag;
}

bool AbstractField::isMultiMux() {
    return isMultiMux_;
}

AbstractField::~AbstractField() {

}

void AbstractField::initialize(FieldElement& fieldElement) {

}

FieldCategory AbstractField::getType() {
    return fieldCategory_;
}

//void AbstractField::setPendingChanged(bool changed, int slot) {
//      this->getFieldValue(slot)->setPendingChanged(changed);
//}

void AbstractField::setDataIntegrity(DataIntegrity dataIntegrity) {
    buffer_ = dataIntegrity;
}

void AbstractField::commit(uint32_t slot) {
    this->getFieldValue(slot)->commit();
}

void AbstractField::registerModifiedField(FieldValueBase* pFV,
                                          MultiplexingContext* context) {
    FieldSynchroManager* pFieldSynchroManager =
        FieldSynchroManager::getInstance();

    pFieldSynchroManager->registerModifiedField(context, this->pDataStore_, isShared_, pFV);
    pFV->setPendingChanged(true);
}

void AbstractField::resetToBeSync(uint32_t slot)
{
    if (this->getFieldValue(slot)->isToBeSync())
    {
        this->getFieldValue(slot)->setToBeSync(false);
    }
}

void AbstractField::restore(FieldElement& fieldElement) {

    std::string str;
    int32_t slot;

    try {

        if (fieldElement.fromPersistency_) {
            // restore normal values
            for (std::map<int32_t, std::string>::iterator iter =
                     fieldElement.fieldValuesCol_.begin(); iter
                     != fieldElement.fieldValuesCol_.end(); iter++) {

                slot = 0;
                if (this->multiplexingManager_ != NULL) {
                    slot = this->multiplexingManager_->requireSlot(iter->first);
                }
                this->copyValue(slot, iter->second);

                // restore extra condition values
                ExtendedMultiplexingManager
                    * emm =
                    dynamic_cast<ExtendedMultiplexingManager*> (this->multiplexingManager_);

                // retrieve the extraconditions for the current cycle

                std::map<int32_t, std::map<std::string, std::string> >::iterator
                    extraValues = fieldElement.fieldExtraValuesCol_.find(
                        iter->first);

                for (std::map<std::string, std::string>::iterator itCycleId =
                         (*extraValues).second.begin(); itCycleId
                         != (*extraValues).second.end(); ++itCycleId) {

                    if (emm != 0) {
                        slot = emm->requireSlot(iter->first, itCycleId->first);
                    } else {
                        throw FesaException(
                            __FILE__,
                            __LINE__,
                            FesaErrorFieldMissingExtendedMultiplexingManager.c_str(),
                            this->name_.c_str());
                    }
                    this->copyValue(slot, itCycleId->second);

                }

            }
        }
        // we come from the instance file so we have to populate all the slots with the same value
        else {

            std::map<int32_t, std::string>::iterator iter =
                fieldElement.fieldValuesCol_.begin();

            int32_t depth = 1;

            if (this->multiplexingManager_ != NULL) {
                depth = this->multiplexingManager_->getDepth();
            }

            // check that we actually have a value
            if (iter != fieldElement.fieldValuesCol_.end()) {
                for (int32_t i = 0; i < depth; i++) {
                    this->copyValue(i, iter->second);
                }
            }

        }

    } catch (FesaException& ex) {

        throw FesaException(ex.getFileName(), ex.getLineNumber(),
                            FesaErrorRestoringField.c_str(), this->name_.c_str());

    } catch (...) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorRestoringField.c_str(), this->name_.c_str());
    }

}

void AbstractField::store(FieldElement& fieldElement) {

    std::string str;

    fieldElement.fieldName_ = this->getName();
    fieldElement.fieldValuesCol_.clear();
    fieldElement.cyclesNamesCol_.clear();

    std::map<std::string, std::string> map;
    std::vector<int32_t> cyclesCol_;

    std::string cycleName;
    int32_t cycleId;

    if (this->multiplexingManager_ != NULL) {
        cyclesCol_
            = this->multiplexingManager_->getTimingDescriptor()->getCycleIdsCol();

    } else {
        // not multiplexed
        cyclesCol_.push_back(-1);
    }

    try {

        //Default values
        for (std::vector<int32_t>::const_iterator itr = cyclesCol_.begin(); itr
                 != cyclesCol_.end(); ++itr) {

            cycleName = "NONE";
            cycleId = -1;
            map.clear();
            int32_t slot = 0;

            cycleId = (*itr);
            if (this->multiplexingManager_ != NULL) {
                slot = this->multiplexingManager_->getLastSlot(cycleId);//cycleID
                cycleName
                    = this->multiplexingManager_->getTimingDescriptor()->getCycleSelectorName(
                        cycleId);
            }

            this->getValueToStore(slot, str);

            fieldElement.fieldValuesCol_.insert(make_pair(cycleId, str));
            fieldElement.cyclesNamesCol_.insert(make_pair(cycleId, cycleName));

            ExtendedMultiplexingManager
                * emm =
                dynamic_cast<ExtendedMultiplexingManager*> (this->multiplexingManager_);
            if (emm != 0) {
                std::vector<std::string> extraCriterionCol =
                    emm->getExtraCriterionCol();

                for (uint32_t ext = 0; ext < extraCriterionCol.size(); ext++) {

                    int32_t slot =
                        emm->getLastSlot(cycleId, extraCriterionCol[ext]);
                    getValueToStore(slot, str);
                    map.insert(make_pair(extraCriterionCol[ext], str));

                }
            }
            fieldElement.fieldExtraValuesCol_.insert(make_pair(cycleId, map));
        }
    }

    catch (FesaException& ex) {
        throw FesaException(ex.getFileName(), ex.getLineNumber(),
                            FesaErrorStoringField.c_str(), this->name_.c_str());
    } catch (...) {
        throw FesaException(__FILE__, __LINE__, FesaErrorStoringField.c_str(),
                            this->name_.c_str());
    }

}

} // fesa