AbstractServerAction.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef ABSTRACT_SERVER_ACTION_H_
#define ABSTRACT_SERVER_ACTION_H_

#include <fesa-core/Core/FesaDefs.h>
#include <fesa-core/Core/AbstractMsgQueue.h>
#include <fesa-core/Core/OnDemandProducer.h>
#include <fesa-core/Core/AbstractAction.h>

#include <cmw-rda/Data.h>

#include <vector>
#include <string>
#include <map>

class rdaData;

namespace fesa
{

class MultiplexingContext;
class AbstractServiceLocator;
class RequestEvent;
class AbstractDevice;
class FesaStream;
class Mutex;
class NotificationProducer;

struct ServerActionConfig
{
                //name of the FESA-class, to which this server-action belongs
                std::string className_;

                std::string name_;

                std::vector<std::string> notifiedPropertiesCol_;

                std::vector<std::string> disablingFieldNamesCol_;

                std::vector<std::string> disablingGlobalFieldNamesCol_;

                bool partialSetIsAllowed_;

                bool needFilter_;

                bool autoNotification_;

                bool transactionalSetIsAllowed_;

                bool defaultImpl_;
};

class AbstractServerAction : public AbstractAction
{
        public:

                AbstractServerAction(ServerActionConfig& actionConfig, const AbstractServiceLocator* serviceLocator, const std::map<std::string, const AbstractServiceLocator*> serviceLocatorRelatedClasses);

                virtual ~AbstractServerAction();

                // Either we can use this (change Property.cpp) or remove the default value from here.
                // Looking at the use we do of reqType, it seems is redundant with the use of ioType, we could use only ioType?
                virtual void execute(RequestEvent* evt, AbstractDevice& dev, const rdaData& filter, rdaData& data,
                         IOType ioType, RequestType reqType) = 0;

                virtual bool needFilter();

                virtual void performCommit(MultiplexingContext& transactionCtxt,
                                                AbstractDevice *transactionDevice) = 0;

                virtual void performRollback(MultiplexingContext& transactionCtxt,
                                                AbstractDevice* transactionDevice) = 0;

    const std::string& getName();

                virtual void printConfig(FesaStream* configStream);

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


                static void releaseStaticObjects();

        protected:

                std::vector<std::string> notifiedPropertiesCol_;

                std::vector<std::string> disablingFieldNamesCol_;

                std::vector<std::string> disablingGlobalFieldNamesCol_;

                bool partialSetIsAllowed_;

                bool needFilter_;

                bool autoNotification_;

                bool transactionalSetIsAllowed_;

                bool defaultImpl_;

                AbstractDevice* pGlobalDevice_;

                NotificationProducer* theNotificationProducer_;

                void checkInvalidatingFields(AbstractDevice* device, MultiplexingContext* ctx);

                void notify(MultiplexingContext& transactionCtxt, AbstractDevice& device,
                                                RequestType reqType = GET);
};

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

}

#endif /* ABSTRACTSERVERACTION_H_ */