Subscription.h

#ifndef _RDA_SUBSCRIPTION_H_
#define _RDA_SUBSCRIPTION_H_
//
// 26 Feb 2004, N.Trofimov
// 19 Jul 2006, W.Gajewski
//    - omniORB adaptation
//
#include <IceUtil/RecMutex.h>
#include <IceUtil/Monitor.h>
#include <rda/RDAService.h>

using namespace IceUtil;

class rdaSubscription : public rdaReplyHandler
{
   friend class SubscriptionThread;

   static rdaRDAService* m_rda;
   static rdaSet m_subscriptions;
   static Monitor<RecMutex> m_monitor;
   static SubscriptionThread* m_thread;
   static rdaLogger* m_logger;

   char* m_device;
   char* m_property;
   char* m_cycle;
   rdaData* m_context;
   bool m_onChange;

   rdaDeviceHandle* m_handle;
   rdaRequest* m_request;
   bool m_rejected;
   
   static void init();

   void updateState();
   void createHandle();
   void subscribe();

   rdaSubscription(const rdaSubscription&);
   void operator=(const rdaSubscription&);

   protected:

   // throws InternalError
      rdaSubscription(const char* device,
                      const char* property,
                      const char* cycle,
                      const rdaData* context,
                      bool onChange);

  
      virtual void handleValue(const rdaData& value) = 0;
      virtual void handleError(const rdaIOError& err) = 0;

   

      virtual void confirmed() {}
      virtual void rejected(const rdaException& why);
      virtual void disconnected() {}
      virtual void reconnected() {}


   public:

      virtual ~rdaSubscription();

      const char* getDevice() const     { return m_device; }
      const char* getProperty() const   { return m_property; }
      const char* getCycle() const      { return m_cycle; }
      bool isOnChange() const           { return m_onChange; }
      const rdaData* getContext() const { return m_context; }



      bool isConfirmed() const          { return m_request != 0; }
      bool isRejected() const           { return m_rejected; }


      // from ReplyHandler

      virtual void handleReply(const rdaRequest&, const rdaData& value)
      {
         handleValue(value);
      }

     virtual void disconnected(const rdaRequest&);

     virtual void reconnected(const rdaRequest&)
     {
        reconnected();
     }

     virtual void handleException(const rdaRequest&, const rdaIOError& err)
     {
        handleError(err);
     }

};

#endif

---