ProxyInterface.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef PROXY_INTERFACE_H_
#define PROXY_INTERFACE_H_

#include <fesa-core/Proxy/ProxyReplyHandler.h>
#include <fesa-core/Exception/FesaException.h>

#include <cmw-rda/DeviceHandle.h>

#include <string>
#include <map>

class rdaRDAService;

namespace fesa
{

class ProxyInterface
{
  public:

    ProxyInterface();

    ~ProxyInterface();

    //template<typename DataType> void setProperty(const std::string& deviceName,
    //               DataType& property) throw(FesaException);

    //template<typename DataType, typename FilterType> void setProperty(const std::string& deviceName,
    //                DataType& property,
    //                FilterType& filter) throw(FesaException);

    template<typename DataType> void setProperty(const std::string& deviceName,
                                                 const std::string& cycleSelector, DataType& property);

    template<typename DataType, typename FilterType> void setProperty(const std::string& deviceName,
                                                                      std::string& cycleSelector, DataType& property, FilterType& filter);

    //template<typename DataType> void getProperty(const std::string& deviceName,
    //                DataType& property) throw(FesaException);

    template<typename DataType> void getProperty(const std::string& deviceName,
                                                 const std::string& cycleSelector, DataType& property);

    //template<typename DataType, typename FilterType> void getProperty(const std::string& deviceName,
    //                DataType& property,
    //                FilterType& filter) throw(FesaException);

    template<typename DataType, typename FilterType> void getProperty(const std::string& deviceName,
                                                                      const std::string& cycleSelector, DataType& property, FilterType& filter);

    void subscribe(const std::string& deviceName, const std::string& propertyName);

    void subscribe(const std::string& deviceName, const std::string& propertyName,
                   const std::string& cycleSelector);

    void unsubscribe(const std::string& deviceName, const std::string& propertyName);

    void unsubscribe(const std::string& deviceName, const std::string& propertyName,
                     const std::string& cycleSelector);

    void waitNotification(std::string& deviceName, std::string& propertyName, std::string& cycleSelectorName,
                          rdaData& value);

  private:

    rdaDeviceHandle* getDeviceHandle(const std::string& deviceName);

    rdaRDAService* rda_;

    std::map<std::string, rdaDeviceHandle*> rdaDeviceHandleCollection_;

    std::map<const std::string, rdaRequest*> subscriptionCollection_;

    void registerDevice(const std::string& deviceName);

    ProxyReplyHandler replyHandler_;

    friend class OnSubscriptionEventSource;

};

/*
  template<typename DataType> void ProxyInterface::setProperty(const std::string& deviceName,
  DataType& property) throw(FesaException)
  {
  try
  {
  rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
  device->set(property.getPropertyName().c_str(), *(property.getRdaData()));
  }
  catch(const rdaException& ex)
  {
  throw FesaException(FesaErrorSettingRdaData.c_str(), ex.getMessage(), __FILE__, __LINE__);
  }
  }
*/

/*
  template<typename DataType, typename FilterType> void ProxyInterface::setProperty(const std::string& deviceName,
  DataType& property,
  FilterType& filter) throw(FesaException)
  {
  try
  {
  rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
  device->set(property.getPropertyName().c_str(), *(property.getRdaData()), *(filter.getRdaData()));
  }
  catch(const rdaException& ex)
  {
  throw FesaException(FesaErrorSettingRdaData.c_str(), ex.getMessage(), __FILE__, __LINE__);
  }
  }
*/

template<typename DataType> void ProxyInterface::setProperty(const std::string& deviceName,
                                                             const std::string& cycleSelector, DataType& property)
{
    try
    {
        rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
        device->set(property.getPropertyName().c_str(), cycleSelector.c_str(), *(property.getRdaData()));
    }
    catch (const rdaException& ex)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorSettingRdaData.c_str(), ex.getMessage());
    }
}

template<typename DataType, typename FilterType> void ProxyInterface::setProperty(const std::string& deviceName,
                                                                                  std::string& cycleSelector, DataType& property, FilterType& filter)
{
    try
    {
        rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
        device->set(property.getPropertyName().c_str(), cycleSelector.c_str(), *(property.getRdaData()),
                    *(filter.getRdaData()));
    }
    catch (const rdaException& ex)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorSettingRdaData.c_str(), ex.getMessage());
    }
}

/*
  template<typename DataType> void ProxyInterface::getProperty(const std::string& deviceName,
  DataType& property) throw(FesaException)
  {
  try
  {
  rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
  property.setData(*(device->get(property.getPropertyName().c_str())), false, false, true);
  }
  catch(const rdaException& ex)
  {
  throw FesaException(FesaErrorGettingRdaData.c_str(), ex.getMessage(), __FILE__, __LINE__);
  }
  }
*/

/*
  template<typename DataType, typename FilterType> void ProxyInterface::getProperty(const std::string& deviceName,
  DataType& property,
  FilterType& filter) throw(FesaException)
  {
  try
  {
  rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
  property.setData((*device->get(property.getPropertyName().c_str(), filter.getRdaData())), false, false, true);
  }
  catch(const rdaException& ex)
  {
  throw FesaException(FesaErrorGettingRdaData.c_str(), ex.getMessage(), __FILE__, __LINE__);
  }
  }
*/

template<typename DataType> void ProxyInterface::getProperty(const std::string& deviceName,
                                                             const std::string& cycleSelector, DataType& property)
{
    try
    {
        rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
        property.setData((*device->get(property.getPropertyName().c_str(), cycleSelector.c_str())), false, false,
                         true);
    }
    catch (const rdaException& ex)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorGettingRdaData.c_str(), ex.getMessage());
    }
}

template<typename DataType, typename FilterType> void ProxyInterface::getProperty(const std::string& deviceName,
                                                                                  const std::string& cycleSelector, DataType& property, FilterType& filter)
{
    try
    {
        rdaDeviceHandle* device = ProxyInterface::getDeviceHandle(deviceName);
        property.setData((*device->get(property.getPropertyName().c_str(), cycleSelector.c_str(),
                                       filter.getRdaData())), false, false, true);
    }
    catch (const rdaException& ex)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorGettingRdaData.c_str(), ex.getMessage());
    }
}

} // fesa

#endif // PROXY_INTERFACE_H_