SubscriptionTreeManager.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef SUBSCRIPTION_TREE_MANAGER_H_
#define SUBSCRIPTION_TREE_MANAGER_H_

#include <fesa-core/RDADeviceServer/SubscriptionCycle.h>
#include <fesa-core/RDADeviceServer/NotificationThreadFactory.h>
#include <fesa-core/Core/FesaDefs.h>
#include <fesa-core/Utilities/Mutex.h>

#include <string>
#include <map>
#include <boost/shared_ptr.hpp>

class rdaData;
class rdaValueChangeListener;

namespace fesa
{

class AbstractDevice;
class Property;
class MultiplexingContext;
class ManualNotificationMessage;
class SubscriptionParameter;
class Notification;

class SubscriptionTreeManager
{
  public:

    SubscriptionTreeManager(bool useFastUpdate);
    SubscriptionTreeManager(const SubscriptionTreeManager& other);
    SubscriptionTreeManager& operator=(const SubscriptionTreeManager& other);


    bool initialize();

    void addSubscriber(const std::string& className, AbstractDevice& device, Property& property,
                       const std::string& cycleSelector, const rdaData& filter, rdaValueChangeListener* subscriber);

    void removeSubscriber( AbstractDevice& device, Property& property, const std::string& cycleSelector,
                           rdaValueChangeListener* subscriber);

    void notify(uint32_t IDKey, MultiplexingContext& muxContext,
                RequestType& reqType);

    void notify(ManualNotificationMessage* msg, RequestType& reqType);


    void reportInternalError(const std::string& errorCategory, int32_t errorCode, const std::string&  message);

    ~SubscriptionTreeManager();

  private:

    boost::shared_ptr<SubscriptionParameter> addSubscriptionParam(const std::string& paramName, AbstractDevice& device, Property& property, const std::string& cycleSelector,
                                                                  const rdaData& filter, rdaValueChangeListener* subscriber);

    void initNotifications();

    //            void addGlobalDevicesToNotificationIDCollection();

    Mutex treeMutex_;

    typedef std::map<uint32_t, boost::shared_ptr<Notification> > NotificationMap;
    typedef NotificationMap::iterator NotificationItr;
    NotificationMap notifications_;

    typedef std::map<std::string, boost::shared_ptr<SubscriptionParameter> > SubscriptionMap;
    typedef SubscriptionMap::iterator SubscriptionItr;
    SubscriptionMap subscriptions_;

    SubscriptionCycle subscriptionCycle_;

    bool initializationSucessfull_;

    //            std::vector<SubscriptionParameter*> waitingSubscriberCol_;


    int32_t lastErrorCode_;

    bool useFastUpdate_;

    NotificationThreadFactory notificationThreadFactory_;

    void printState(std::string& header);

};

} // fesa

#endif // SUBSCRIPTION_TREE_MANAGER_H_