AbstractServerAction.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/Server/AbstractServerEquipment.h>
#include <fesa-core/Server/AbstractServerDeviceClass.h>
#include <fesa-core/Server/AbstractServerController.h>
#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/DataStore/FaultField.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/DataStore/FieldSynchroManager.h>
#include <fesa-core/Core/NotificationProducer.h>
#include <fesa-core/Core/MessageTypes.h>
#include <fesa-core/Core/OnDemandProducer.h>
#include <fesa-core/Diagnostic/FesaStream.h>

namespace fesa
{

AbstractServerAction::AbstractServerAction(ServerActionConfig& actionConfig, const AbstractServiceLocator* serviceLocator, const std::map<std::string, const AbstractServiceLocator*> serviceLocatorRelatedClasses) :
        AbstractAction(actionConfig.name_,actionConfig.className_,serviceLocator,serviceLocatorRelatedClasses),
        notifiedPropertiesCol_(actionConfig.notifiedPropertiesCol_),
        disablingFieldNamesCol_(actionConfig.disablingFieldNamesCol_), disablingGlobalFieldNamesCol_(actionConfig.disablingGlobalFieldNamesCol_),
        partialSetIsAllowed_(actionConfig.partialSetIsAllowed_), needFilter_(actionConfig.needFilter_),
        autoNotification_(actionConfig.autoNotification_), transactionalSetIsAllowed_(actionConfig.transactionalSetIsAllowed_),
        defaultImpl_(actionConfig.defaultImpl_), pGlobalDevice_(0)
{
        theNotificationProducer_ = NotificationProducer::getInstance();
}

AbstractServerAction::~AbstractServerAction()
{

}

void AbstractServerAction::releaseStaticObjects()
{

}

void AbstractServerAction::checkInvalidatingFields(AbstractDevice* device, MultiplexingContext* ctx)
{
    for (uint32_t i = 0; i < disablingFieldNamesCol_.size(); ++i)
        {
                AbstractField* aF(device->getField(disablingFieldNamesCol_[i].c_str()));
                FaultField<FaultField_DataType>* pFF = (FaultField<FaultField_DataType>*) aF;
                if (pFF->isRaised(ctx))
                {
                        throw FesaException(__FILE__, __LINE__, FesaErrorActionDisabledByFaultField.c_str(),
                                                        pFF->getDescription().c_str());
                }
        }
        if (pGlobalDevice_ == 0)
        {
                AbstractServerEquipment* equipment = AbstractServerEquipment::getInstance();
                pGlobalDevice_
                                                = (equipment->getDeviceClassFromDeviceName(device->getName())->getDeviceFactory()->getGlobalDevice());
        }
        for (uint32_t i = 0; i < disablingGlobalFieldNamesCol_.size(); ++i)
        {
                AbstractField* aF(pGlobalDevice_->getField(disablingGlobalFieldNamesCol_[i].c_str()));
                FaultField<FaultField_DataType>* pFF = (FaultField<FaultField_DataType>*) aF;
                if (pFF->isRaised(ctx))
                {
                        throw FesaException(__FILE__, __LINE__, FesaErrorActionDisabledByFaultField.c_str(),
                                                        pFF->getDescription().c_str());
                }
        }
        return;
}

void AbstractServerAction::notify(MultiplexingContext& context, AbstractDevice& device, RequestType reqType)
{
        if (!notifiedPropertiesCol_.empty())
        {
                AbstractServerEquipment* equipment = AbstractServerEquipment::getInstance();
                AbstractServerDeviceClass* deviceclass = equipment->getDeviceClassFromDeviceName(device.getName());
                std::vector<std::string>::iterator iter;

                ManualNotificationMessage mnm(deviceclass->getName());
                mnm.muxContext_=&context;

                for (iter = notifiedPropertiesCol_.begin(); iter != notifiedPropertiesCol_.end(); ++iter)
                {
                        mnm.addPropertyAndDevice(*iter,device.getName());
                }
                theNotificationProducer_->sendManualNotification(mnm);
        }
}

void AbstractServerAction::printConfig(FesaStream* configStream)
{
        *configStream << "name=\"" << name_ << " implementation=\"" << ((defaultImpl_)? "default" : "custom") << "\">" << std::endl;
        //list of disabling fields
        *configStream << "\t\t\t\t\t\t<disabling-fields name=\"";
        for(std::vector<std::string>::iterator it=disablingFieldNamesCol_.begin(); it!=disablingFieldNamesCol_.end(); ++it)
        {
                *configStream << *it << " ";
        }
        for(std::vector<std::string>::iterator it=disablingGlobalFieldNamesCol_.begin(); it!=disablingGlobalFieldNamesCol_.end(); ++it)
        {
                *configStream << *it << " ";
        }
        *configStream << "\"" << std::endl;

        if (!notifiedPropertiesCol_.empty())
        {
                //list of properties to be notified
                *configStream << "\t\t\t\t\t\t<notified-properties name=\"";
                for(std::vector<std::string>::iterator it=notifiedPropertiesCol_.begin(); it!=notifiedPropertiesCol_.end(); ++it)
                {
                        *configStream << *it << " ";
                }
                *configStream << "\"" << std::endl;
        }
}

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

}

bool AbstractServerAction::needFilter()
{

        return needFilter_;
}

}