Property.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Server/Property.h>

#include <fesa-core/Server/RequestEvent.h>
#include <fesa-core/Server/AbstractServerAction.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Synchronization/NoneContext.h>
#include <fesa-core/Synchronization/TimingContext.h>
#include <fesa-core/Synchronization/SynchronizationLabObjectFactory.h>
#include <fesa-core/Synchronization/CycleDescriptor.h>
#include <fesa-core/Diagnostic/FesaStream.h>

#include <cmw-rda/Data.h>


namespace fesa
{

Property::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) :
    name_(name),
    isGlobal_(isGlobal),
    isOnChange_(isOnChange),
    isSubscribable_(isSubscribable),
    type_(type),
    multiplexed_(multiplexed),
    priorityOffset_(priorityOffset),
    notificationThreadKey_(notificationThreadKey),
    getServerAction_(getServerAction),
    setServerAction_(setServerAction)
{
    //TODO: Fix that as soon as the MetaModel supports the OnChange mechanism
    //isOnChange_ = isOnChange;
}


Property::~Property()
{
    if (getServerAction_ != NULL)
    {
        delete getServerAction_;
        getServerAction_ = NULL;
    }

    if (setServerAction_ != NULL)
    {
        delete setServerAction_;
        setServerAction_ = NULL;
    }
}

void Property::get(AbstractDevice& device, const std::string& cycleSelector, const rdaData& filter, rdaData& value,
                   RequestType reqType)
{
    // check if the action is not NULL
    if (getServerAction_ == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorPropertyNotReadable.c_str(), name_.c_str());

    // validate the parameters
    validateParameters(device, cycleSelector, !(filter.isEmpty()), reqType);

    MultiplexingContext ctx;
    if (cycleSelector.empty())
    {
        ctx = NoneContext();
    }
    else
    {
        ctx = TimingContext(cycleSelector);
    }

    RequestEvent ev(&ctx);

    ctx.setSettingAccess(MultiplexingContext::CHECK_FLAG_TO_BE_SYNC);
    // acquisition fields (mux manager occurence type) should be only accessible  from RT part
    ctx.setAcquisitionAccess(MultiplexingContext::SET_NOT_ALLOWED);

    // Initialize the context with extra condition if any is specified
    if (!filter.isEmpty() && filter.contains(EXTRA_CRITERION_NAME.c_str()))
    {
        ctx.setExtraCondition(filter.extractString(EXTRA_CRITERION_NAME.c_str()));
    }
    getServerAction_->execute(&ev, device, filter, value, Output, reqType);

}

void Property::get(AbstractDevice& device, MultiplexingContext& context, const rdaData& filter, rdaData& value,
                   RequestType reqType)
{
    // check if the action is not NULL
    if (getServerAction_ == NULL)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorPropertyNotReadable.c_str(), name_.c_str());
    }

    RequestEvent ev(&context);
    // The current method is used for the notification mechanism, and
    // in case of a setting property, any get access of setting fields should
    // access the latest updated data, being this either pending or active buffer.


    context.setSettingAccess(MultiplexingContext::CHECK_FLAG_TO_BE_SYNC);
    // acquisition fields (mux manager occurence type) should be only accessible  from RT part
    context.setAcquisitionAccess(MultiplexingContext::SET_NOT_ALLOWED);
    getServerAction_->execute(&ev, device, filter, value, Output, reqType);
}

void Property::set(AbstractDevice& device, const std::string& cycleSelector, const rdaData& filter,
                   const rdaData& value)
{
    // check if the action is not NULL
    if (setServerAction_ == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorPropertyNotWritable.c_str(), name_.c_str());

    // validate the parameters
    validateParameters(device, cycleSelector, !(filter.isEmpty()), SET);

    // TODO validate against control access manager
    MultiplexingContext ctx;
    if (cycleSelector.empty())
    {
        ctx = NoneContext();
    }
    else
    {
        ctx = TimingContext(cycleSelector);
    }

    // Modify the setting access mask for the context
    // we allow set access for setting fields
    ctx.setSettingAccess(MultiplexingContext::SET_ALLOWED);
    // acquisition fields (mux manager occurence type) should be only accessible  from RT part
    ctx.setAcquisitionAccess(MultiplexingContext::SET_NOT_ALLOWED);

    RequestEvent ev(&ctx);
    // Initialize the context with extra condition if any is specified
    if (!filter.isEmpty() && filter.contains(EXTRA_CRITERION_NAME.c_str()))
    {
        ctx.setExtraCondition(filter.extractString(EXTRA_CRITERION_NAME.c_str()));
    }

    //we have to cast the value here, because we recieve it from RDA as const
    //and the execute method has to work for get and set actions
    setServerAction_->execute(&ev, device, filter, *const_cast<rdaData*> (&value), Input, SET);
}

void Property::validateParameters(AbstractDevice& dev, const std::string& cycleSelector, bool hasFilter,
                                  RequestType reqType)
{

    // Check if the device is a global-instance or a device-instance
    GlobalDevice* globdev = dynamic_cast<GlobalDevice*> (&dev);
    // Check the consistency: global-property can be used only with the global-deviceinstance
    // device-property can be used only with device-instance
    if (((globdev != NULL) && (!isGlobal_)) || ((globdev == NULL) && (isGlobal_)))
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorMixedGlobalWithNoneGlobal.c_str());
    }

    if (reqType == SUBSCRIBE && !isSubscribable_)
    {
        throw FesaInvalidResourceException(__FILE__, __LINE__, FesaErrorPropertyNotSubscribable.c_str(),
                                           name_.c_str());
    }

    // cycleSelector cannot be empty if the dev/property is multiplexed and the requestType is Get or Set
    if (cycleSelector.empty())
    {
        if (dev.isMultiplexed() && multiplexed_ && reqType != SUBSCRIBE)
            throw FesaException(__FILE__, __LINE__, FesaErrorCycleNULLInMultiplexedProperty.c_str(), name_.c_str());
    }
    else
    {
        // Check cycleSelector validity
        validateCycleSelector(dev, cycleSelector, reqType);
    }

    // Check if a filter is required
    if (hasFilter != needFilter())
    {
        if (needFilter())
            throw FesaException(__FILE__, __LINE__, FesaErrorPropertyNeedsFilter.c_str(), name_.c_str());
        else
            throw FesaException(__FILE__, __LINE__, FesaErrorPropertyNotSupportFilter.c_str(), name_.c_str());
    }
}// end validateParameters


void Property::validateCycleSelector(fesa::AbstractDevice& device, const std::string& cycleSelector,
                                     fesa::RequestType reqType)
{
    CycleSelector timingSelector;
    fesa::parseCycleSelector(cycleSelector, timingSelector);

    // check timingDomain between the device and the one specified by the cycleSelector
    const std::string& timDom = device.timingDomain.get();

    if (timingSelector.domain_ != timDom)
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongTimingDomain.c_str(), timingSelector.domain_.c_str(),
                            timDom.c_str());

    // verify if the cycle-descriptor is valid
    SynchronizationLabObjectFactory* syncFactory = SynchronizationLabObjectFactory::getInstance();
    CycleDescriptor* td = syncFactory->getCycleDescriptor(timingSelector.domain_, timingSelector.criterion_);

    td->isValidCycleSelector(cycleSelector);

    if ((reqType != SUBSCRIBE) && (device.isMultiplexed()) && (strcmp(timingSelector.criterion_.c_str(),
                                                                      device.mainMuxCriterion.get()) != 0))

        throw FesaException(__FILE__, __LINE__, FesaErrorIllegalTiming.c_str(), name_.c_str());

    //Checking cycleSelector may require additional Lab specific check.
    //validateCycleSelector is a Lab implementation throwing an exception in case of invalid cycleSelector
    fesa::validateCycleSelector(timingSelector, reqType);
}

int64_t Property::getDataTimestamp(AbstractDevice& device, MultiplexingContext& context, const rdaData& filter)
{
    //        return getServerAction_->getDataTimestamp(device, context, filter);
    return 0;
}

void Property::printConfig(FesaStream* configStream)
{
    *configStream << "\t\t\t\t\t<property name=\"" << name_ << "\" multiplexed=\"" << multiplexed_
                  << "\" onChange=\"" << isOnChange_ << "\" subscribable=\"" << isSubscribable_ << "\">" << std::endl;
    if(getServerAction_ != NULL)
    {
        *configStream << "\t\t\t\t\t\t<get-server-action ";
        getServerAction_->printConfig(configStream);
        *configStream << "\t\t\t\t\t\t</get-server-action>";
    }
    if(setServerAction_ != NULL)
    {
        *configStream << "\t\t\t\t\t\t<set-server-action ";
        getServerAction_->printConfig(configStream);
        *configStream << "\t\t\t\t\t\t</set-server-action>";
    }
    *configStream << "\t\t\t\t\t</property>" << std::endl;
}

void Property::printState(FesaStream* fesaStream, double elapsedTime)
{

}

const std::string& Property::getNotificationThreadKey()
{
    return notificationThreadKey_;
}

const std::string& Property::getClassName()
{
    return className_;
}

} // fesa