DeviceFactory.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef DEVICE_FACTORY_H_
#define DEVICE_FACTORY_H_

#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/DataStore/HeapFactory.h>
#include <fesa-core/DataStore/ShmFactory.h>

#include <string>
#include <vector>

namespace fesa
{

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
class DeviceFactory : public AbstractDeviceFactory
{
  public:

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

    GlobalDeviceType* getGlobalDevice();

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

    ~DeviceFactory();

  protected:

    DeviceFactory(const std::string& className);

    static DeviceFactory* instance_;

  private:
    DeviceFactoryImp<GlobalDeviceType, DomainStoreType, DevInstType>* imp_;
};

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

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
DeviceFactory<GlobalDeviceType, DomainStoreType, DevInstType>::DeviceFactory(const std::string& className) :
    AbstractDeviceFactory(className)
{
    if (AbstractEquipment::getInstance()->getProcessType() == unsplit)
    {
        imp_ = new HeapFactory<GlobalDeviceType, DomainStoreType, DevInstType> (className);
    }
    else
    {
        imp_ = new ShmFactory<GlobalDeviceType, DomainStoreType, DevInstType> (className);
    }
    imp_->initialize();

    // Update the abstract-device collection for the Framework purpose
    for (uint32_t i = 0; i < imp_->getDeviceCollection().size(); i++)
    {
        pAbstractDeviceCol_.push_back((imp_->getDeviceCollection())[i]);
    }

}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
DeviceFactory<GlobalDeviceType, DomainStoreType, DevInstType>::~DeviceFactory<GlobalDeviceType, DomainStoreType,
                                                                              DevInstType>()
{
    // delete device-factory implementation class
    delete imp_;
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline DevInstType* DeviceFactory<GlobalDeviceType, DomainStoreType, DevInstType>::getDevice(
    const std::string& devName)
{
    return imp_->getDevice(devName);
}

template<typename GlobalDeviceType, typename DomainStoreType, typename DevInstType>
inline GlobalDeviceType* DeviceFactory<GlobalDeviceType, DomainStoreType, DevInstType>::getGlobalDevice()
{
    return imp_->getGlobalDevice();
}

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

} // fesa

#endif // DEVICE_FACTORY_H_