DeviceFactoryImp.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef DEVICE_FACTORY_IMP_H_
#define DEVICE_FACTORY_IMP_H_

#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/DataStore/InitializeDataStoreManager.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Synchronization/SynchronizationLabObjectFactory.h>
#include <fesa-core/Synchronization/AbstractMultiplexingManager.h>
#include <fesa-core/Persistency/PersistencyManager.h>
#include <fesa-core/Persistency/PersistencyUnit.h>
#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/Utilities/StringUtilities.h>
#include <fesa-core/Exception/FesaException.h>

#include <string>
#include <vector>
#include <sys/stat.h>


namespace fesa
{

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
class DeviceFactoryImp
{
  public:
    DeviceFactoryImp(const std::string& className);

    virtual ~DeviceFactoryImp();

    const std::vector<DevInstType*>& getDeviceCollection();

    GlobalDeviceType* getGlobalDevice();

    DevInstType* getDevice(const std::string& deviceName);

    void initialize();

  protected:

    virtual bool setUpMemory() = 0;

    void computeMemorySize();

    void mapFields(char* p, bool initializeFields);

    void unmapFields();

    void registerPersistenceFields();

    std::vector<DevInstType *> pDeviceCol_;

    std::vector<DomainStoreType*> pDomainStoreCol_;

    GlobalDeviceType* pGlobalDevice_;

    int32_t size_;

    int32_t globalDeviceSize_;

    int32_t domainStoreSize_;

    int32_t devicesSize_;

    int32_t muxManagersSize_;

    int32_t equimentDataSize_;

  private:

    void createDevices(const std::vector<DeviceElement*>& pDeviceElementCol);

    void createDomainStores(const std::vector<DomainStoreElement*>& pDomainStoreElementCol);

    void createGlobalDevice(GlobalDeviceElement& pGlobalDeviceElement);

    void configureFields(DataStore* dataStore, DataStoreElement* dataStoreElement);

    void initializeDevices(const std::vector<DeviceElement*>& pDeviceElementCol);

    void initializeDomainStores(const std::vector<DomainStoreElement*>& pDomainStoreElementCol);

    void initializeGlobalDevice(GlobalDeviceElement& pGlobalDeviceElement);

    std::string className_;
};

//******************************************************************

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::DeviceFactoryImp(const std::string& className) :
    pDeviceCol_(0), pDomainStoreCol_(0), pGlobalDevice_(0), className_(className)
{
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::~DeviceFactoryImp<GlobalDeviceType,
                                                                                    DomainStoreType, DevInstType>()
{
    //delete all device-factory resources
    for (uint32_t i = 0; i < pDomainStoreCol_.size(); pDomainStoreCol_[i++])
    {
        delete pDomainStoreCol_[i];
    }
    for (uint32_t i = 0; i < pDeviceCol_.size(); pDeviceCol_[i++])
    {
        delete pDeviceCol_[i];
    }

    delete pGlobalDevice_;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::initialize()
{


    bool optional = AbstractEquipment::getInstance()->isClassOptional(className_);

    struct stat stFileInfo;

    std::string instanceFile = AbstractEquipment::getInstance()->getDeviceDataFileName();

    int32_t exists = stat(instanceFile.c_str(),&stFileInfo); // returns 0 if the file exists

    // file does not exist and not optional exception
    if (exists != 0 && !optional)
    {
        throw FesaFileException(__FILE__, __LINE__, FesaErrorOpenXMLFile.c_str(), instanceFile.c_str());

    }
    // does not exist but it is optional. return
    else if (exists != 0 && optional)
    {
        return;
    }

    InitializeDataStoreManager* manager = new InitializeDataStoreManager(className_);

    GlobalDeviceElement& pGlobalDeviceElement = manager->retrieveGlobalDeviceElement();

    const std::vector<DeviceElement*>& pDeviceElementCol = manager->retrieveDeviceElements();

    const std::vector<DomainStoreElement*>& pDomainStoreElementCol = manager->retrieveDomainStoreElements();

    // Instantiate Device, GlobalDevice and DomainStore concrete objects
    createDevices(pDeviceElementCol);

    createDomainStores(pDomainStoreElementCol);

    createGlobalDevice(pGlobalDeviceElement);


    std::vector<AbstractDevice*> tmpDevices(pDeviceCol_.begin(), pDeviceCol_.end());
    std::vector<DomainStore*> tmpDomains(pDomainStoreCol_.begin(), pDomainStoreCol_.end());

    std::string persistencyFile = AbstractEquipment::getInstance()->getPersistencyFileName(className_);

    // Allocate the related data store memory and map all fields inside
    if (setUpMemory() == true)
    {
        initializeGlobalDevice(pGlobalDeviceElement);

        if (pDeviceElementCol.size() > 0)
            initializeDevices(pDeviceElementCol);

        if (pDomainStoreElementCol.size() > 0)
            initializeDomainStores(pDomainStoreElementCol);

        exists = stat(persistencyFile.c_str(),&stFileInfo);

        if (exists == 0)//check, if file exists
        {
            StoreManager storeManager;//restore persistent field values
            storeManager.restore(*pGlobalDevice_, tmpDevices, tmpDomains, className_);
        }

        EquipmentData::getInstance()->initialize();
    }


    PersistencyUnit * pPersistencyUnit = new PersistencyUnit(*pGlobalDevice_, tmpDevices, tmpDomains,
                                                             persistencyFile);

    (PersistencyManager::getInstance())->registerPersistencyUnit(pPersistencyUnit);

    delete manager;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline GlobalDeviceType* DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::getGlobalDevice()
{
    return pGlobalDevice_;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline DevInstType* DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::getDevice(const std::string& devName)
{
    for (uint32_t i = 0; i < pDeviceCol_.size(); i++)
    {
        if (devName == pDeviceCol_[i]->name.get())
        {
            return pDeviceCol_[i];
        }
    }
    return NULL;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline const std::vector<DevInstType *>& DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::getDeviceCollection()
{
    return pDeviceCol_;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::createDevices(
    const std::vector<DeviceElement*>& pDeviceElementCol)

{

    // Instanciates the Devices .........................................

    for (uint32_t devIdx = 0; devIdx < pDeviceElementCol.size(); devIdx++)
    {
        // ... now the device (generated part) is instantiated with all the fields;
        // each field (during construction) registers itself in the related collection
        DevInstType* pDevice = new DevInstType();

        // create the fields
        this->configureFields(pDevice, pDeviceElementCol[devIdx]);

        pDeviceCol_.push_back(pDevice);

    } // for devices end

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::createGlobalDevice(
    GlobalDeviceElement& pGlobalDeviceElement)
{

    //Instantiate the unique GlobalDevice instance ..........................
    pGlobalDevice_ = new GlobalDeviceType();
    this->configureFields(pGlobalDevice_, &pGlobalDeviceElement);

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::createDomainStores(
    const std::vector<DomainStoreElement*>& pDomainStoreElementCol)
{

    //Instantiates the DomainStore instances if necessary ..................

    for (uint32_t devIdx = 0; devIdx < pDomainStoreElementCol.size(); devIdx++)
    {
        // ... now the domainStore (generated part) is instantiated with all the fields;
        // each field (during construction) registers itself in the vector created above
        DomainStoreType * pDomainStore = new DomainStoreType();

        this->configureFields(pDomainStore, pDomainStoreElementCol[devIdx]);

        pDomainStoreCol_.push_back(pDomainStore);
    } // for domainStore end
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::configureFields(DataStore* dataStore,
                                                                                       DataStoreElement* dataStoreElement)
{

    // ... now we have to create and assign the appropriate MultiplexingManager to each field
    const std::vector<AbstractField*>& pFieldCol = dataStore->getFieldCollection();

    //Lab specific errors are caught in the main
    SynchronizationLabObjectFactory* labFactory = SynchronizationLabObjectFactory::getInstance();

    InitializeDataStoreManager manager(className_);

    AbstractMultiplexingManager* rolling = NULL;

    AbstractMultiplexingManager* multiplexingManager = NULL;
    AbstractMultiplexingManager* extendedMultiplexingManager = NULL;


    // check that the device is multiplexed

    if (dataStoreElement->isMultiplexed())
    {

        if (AbstractEquipment::getInstance()->getProcessType() == unsplit)

        {
            rolling = labFactory->createRollingMultiplexingManager(dataStoreElement->getTimingDomain(),
                                                                   dataStoreElement->getTimingCriterion(), manager.getRollingManagerDepth());

            multiplexingManager = labFactory->createMultiplexingManager(dataStoreElement->getTimingDomain(),
                                                                        dataStoreElement->getTimingCriterion());

        }
        else
        {

            rolling = labFactory->createRollingSharedMultiplexingManager(dataStoreElement->getTimingDomain(),
                                                                         dataStoreElement->getTimingCriterion(), manager.getRollingManagerDepth());

            multiplexingManager = labFactory->createSharedMultiplexingManager(dataStoreElement->getTimingDomain(),
                                                                              dataStoreElement->getTimingCriterion());

        }

    }

    for (uint32_t fieldIdx = 0; fieldIdx < pFieldCol.size(); fieldIdx++)
    {

        FieldElement* pFieldElement = dataStoreElement->getFieldElement(pFieldCol[fieldIdx]->getName());

        if (pFieldElement != NULL)
        {

            pFieldCol[fieldIdx]->initialize(*pFieldElement);

        }

        // if the device is not multiplexed then change the multiplexing value for the field
        if (!dataStoreElement->isMultiplexed())
        {
            pFieldCol[fieldIdx]->setMultiplexed(false);

        }

        // The device and the field are Multiplexed
        // So we have to associate the field with the right multiplexing manager
        // For this, build the complete multiplexing criterion (timingDomain + muxCriterion)


        if (pFieldCol[fieldIdx]->isMultiplexed())
        {
            if (pFieldCol[fieldIdx]->getType() == Acquisition)
            {

                pFieldCol[fieldIdx]->setMultiplexingManager(rolling);
            }
            else
            {

                pFieldCol[fieldIdx]->setMultiplexingManager(multiplexingManager);

            }
        }
        // field not multiplexed
        else
        {
            pFieldCol[fieldIdx]->setMultiplexingManager(NULL);
        }

        if (pFieldCol[fieldIdx]->isMultiMux())
        {

            DeviceElement* device = (DeviceElement*) dataStore;

            extendedMultiplexingManager
                = SynchronizationLabObjectFactory::getInstance()->createExtendedMultiplexingManager(
                    pFieldCol[fieldIdx]->getMultiplexingManager(),
                    device->extraCriterionCol_);

            pFieldCol[fieldIdx]->setMultiplexingManager(extendedMultiplexingManager);
        }

    }

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::initializeGlobalDevice(
    GlobalDeviceElement& pGlobalDeviceElement)
{
    pGlobalDevice_->initializeFromElement(pGlobalDeviceElement);

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::initializeDevices(
    const std::vector<DeviceElement*>& pDeviceElementCol)
{
    if (pDeviceElementCol.size() != pDeviceCol_.size())

        throw FesaException(__FILE__, __LINE__, FesaErrorDeviceFactoryCheckingDeviceCollectionSize.c_str(),
                            StringUtilities::toString(static_cast<int32_t>(pDeviceElementCol.size())).c_str(), StringUtilities::toString(
                                    static_cast<int32_t>(pDeviceCol_.size())).c_str());
    else

        for (uint32_t iDevEl = 0; iDevEl < pDeviceElementCol.size(); iDevEl++)
        {
            pDeviceCol_[iDevEl]->initializeFromElement(*pDeviceElementCol[iDevEl]);
        }

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::initializeDomainStores(
    const std::vector<DomainStoreElement*>& pDomainStoreElementCol)
{

    if (pDomainStoreElementCol.size() != pDomainStoreCol_.size())
    {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorDeviceFactoryCheckingDomainStoreCollectionSize.c_str(),
                            StringUtilities::toString(static_cast<int32_t>(pDomainStoreElementCol.size())).c_str(),
                            StringUtilities::toString(static_cast<int32_t>(pDomainStoreCol_.size())).c_str());
    }
    else
    {

        for (uint32_t iDomEl = 0; iDomEl < pDomainStoreElementCol.size(); iDomEl++)
        {
            pDomainStoreCol_[iDomEl]->initializeFromElement(*pDomainStoreElementCol[iDomEl]);

        }

    }

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::computeMemorySize()

{
    muxManagersSize_ = AbstractMultiplexingManager::getMemorySizeToAllocate();

    // Compute the size of all Fields values for the GlobalDevice
    globalDeviceSize_ = pGlobalDevice_->getMemorySizeToAllocate();

    // Now compute the size of domainStore if any
    domainStoreSize_ = 0;
    for (uint32_t devIdx = 0; devIdx < this->pDomainStoreCol_.size(); devIdx++)
    {
        domainStoreSize_ += pDomainStoreCol_[devIdx]->getMemorySizeToAllocate();
    }

    // Now compute the size of devices
    devicesSize_ = 0;
    for (uint32_t devIdx = 0; devIdx < this->pDeviceCol_.size(); devIdx++)
    {
        devicesSize_ += pDeviceCol_[devIdx]->getMemorySizeToAllocate();
    }

    equimentDataSize_ = 0;

    EquipmentData * equipmentData = EquipmentData::getInstance();
    if (equipmentData->isInitialize_ == NULL)
    {
        equimentDataSize_ = equipmentData->getMemorySizeToAllocate();

    }

    // The result of the memory computation
    size_ = muxManagersSize_ + globalDeviceSize_ + domainStoreSize_ + devicesSize_ + equimentDataSize_;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::mapFields(char* p, bool initializeFields)
{
    char* pAddrMuxManagersSpace = p;
    char* pAddrGlobalDeviceSpace = pAddrMuxManagersSpace + muxManagersSize_;
    char* pAddrDomainStoreSpace = pAddrGlobalDeviceSpace + globalDeviceSize_;
    char* pAddrDeviceInstanceSpace = pAddrDomainStoreSpace + domainStoreSize_;
    char* pAddrEquipmentInstanceSpace = pAddrDeviceInstanceSpace + devicesSize_;

    AbstractMultiplexingManager::mapMemory(pAddrMuxManagersSpace);

    p = pAddrGlobalDeviceSpace;
    pGlobalDevice_->mapMemory(p, initializeFields);

    p = pAddrDomainStoreSpace;
    for (uint32_t devIdx = 0; devIdx < pDomainStoreCol_.size(); devIdx++)
    {
        pDomainStoreCol_[devIdx]->mapMemory(p, initializeFields);
        p += pDomainStoreCol_[devIdx]->getMemorySizeToAllocate();
    }

    p = pAddrDeviceInstanceSpace;
    for (uint32_t devIdx = 0; devIdx < pDeviceCol_.size(); devIdx++)
    {
        pDeviceCol_[devIdx]->mapMemory(p, initializeFields);
        p += pDeviceCol_[devIdx]->getMemorySizeToAllocate();
    }

    p = pAddrEquipmentInstanceSpace;

    EquipmentData * equipmentData = EquipmentData::getInstance();
    if (equipmentData->isInitialize_ == NULL)
    {
        equipmentData->mapMemory(p,initializeFields);
        *(equipmentData->isInitialize_) = true;
    }

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
void DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>::unmapFields()
{
    // In theory this method should unmap all the fields; but as so far the only field  that is used
    // during the startup of the memory is the equipmentData.initialize; this method only unmap this field
    EquipmentData * equipmentData = EquipmentData::getInstance();
    equipmentData->isInitialize_ = NULL;
}

} // fesa

#endif // DEVICE_FACTORY_IMP_H_