Property.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef PROPERTY_H_
#define PROPERTY_H_

#include <fesa-core/Server/AbstractServerAction.h>
#include <fesa-core/Core/FesaDefs.h>

#include <vector>
#include <string>

class rdaData;

namespace fesa
{

class SubscriptionParameter;
class AbstractDevice;
class MultiplexingContext;
class FesaStream;

class Property
{
  public:

    Property(const std::string& name, bool isGlobal, bool isOnChange, bool isSubscribable, PropertyType type,
             bool multiplexed, int32_t priorityOffset, const std::string& notificationThreadKey,
             AbstractServerAction* getServerAction, AbstractServerAction* setServerAction, const std::string& className);

    virtual ~Property();

    template<typename PropDataType, typename PropFilterType>
    void get(AbstractDevice& device, const std::string& cyleSelector, const PropFilterType& filter,
             const PropDataType& value);
    template<typename PropDataType>
    void get(AbstractDevice& device, const std::string& cyleSelector, const PropDataType& value);

    template<typename PropDataType, typename PropFilterType>
    void set(AbstractDevice& dev, const std::string& cyleSelector, const PropDataType& data,
             const PropFilterType& filter);

    template<typename PropDataType>
    void set(AbstractDevice& dev, const std::string& cyleSelector, const PropDataType& data);

    void validateParameters(AbstractDevice& dev, const std::string& cycleSelector, bool hasFilter,
                            RequestType reqType);
    int64_t getDataTimestamp(AbstractDevice& device, MultiplexingContext& context,
                               const rdaData& filter);

    /************************* get methods ******************************/
    std::string& getName();

    PropertyType getType();

    int32_t getPriorityOffset();

    bool isGlobal();

    bool isOnChange();

    bool isMultiplexed();

    bool isSubscribable();

    virtual void printConfig(FesaStream* configStream);

    virtual void printState(FesaStream* fesaStream, double elapsedTime);

    //            void reportErrorToSubscribers(std::string Message);


    const std::string& getNotificationThreadKey();

    const std::string& getClassName();


  protected:
    // teh following classes access the protected get/set method using rdaData Object
    friend class AbstractSubscriptionFilter;
    friend class SubscriptionFilter;
    friend class FesaDeviceServer;

    void get(AbstractDevice& device, MultiplexingContext& context, const rdaData& filter,
             rdaData& value, RequestType reqType);

    void get(AbstractDevice& device, const std::string& cycleSelector, const rdaData& filter, rdaData& value,
             RequestType reqType);

    void set(AbstractDevice& device, const std::string& cycleSelector, const rdaData& filter,
             const rdaData& value);

    void
    validateCycleSelector(AbstractDevice& device, const std::string& cycleSelector, RequestType reqType);

    std::string name_;

    bool isGlobal_;

    bool isOnChange_;

    bool isSubscribable_;

    PropertyType type_;

    bool multiplexed_;

    int32_t priorityOffset_;
    std::vector<SubscriptionParameter*> subscribers_;

    std::string notificationThreadKey_;

    AbstractServerAction* getServerAction_;

    AbstractServerAction* setServerAction_;

    bool needFilter();

    std::string className_;



};

inline bool Property::isGlobal()
{
    return isGlobal_;
}

inline bool Property::isOnChange()
{
    return isOnChange_;
}

inline bool Property::isSubscribable()
{
    return isSubscribable_;
}

inline bool Property::isMultiplexed ()
{
    return multiplexed_;
}

inline PropertyType Property::getType()
{
    return type_;
}

inline int32_t Property::getPriorityOffset()
{
    return priorityOffset_;
}

inline bool Property::needFilter()
{
    if (getServerAction_)
        return getServerAction_->needFilter();
    else
        return setServerAction_->needFilter();

}

inline std::string& Property::getName()
{
    return name_;
}

template<typename PropDataType, typename PropFilterType>
void Property::get(AbstractDevice& device, const std::string& cycleSelector, const PropFilterType& filter,
                   const PropDataType& value)
{
    this->get(device, cycleSelector, *(filter.getRdaData()), *(value.getRdaData()));
}

template<typename PropDataType, typename PropFilterType>
void Property::set(AbstractDevice& device, const std::string& cycleSelector, const PropDataType& value,
                   const PropFilterType& filter)
{
    this->set(device, cycleSelector, (*value.getRdaData()), *(filter.getRdaData()));
}

template<typename PropDataType>
void Property::get(AbstractDevice& device, const std::string& cycleSelector, const PropDataType& value)
{
    rdaData dummyRDA;
    this->get(device, cycleSelector, dummyRDA, *(value.getRdaData()));
}

template<typename PropDataType>
void Property::set(AbstractDevice& device, const std::string& cycleSelector, const PropDataType& value)
{
    rdaData dummyRDA;
    this->set(device, cycleSelector, (*value.getRdaData()), dummyRDA);
}

} // fesa

#endif // PROPERTY_H_