TAO/examples/Callback_Quoter/Notifier_i.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Notifier_i.cpp
   5  *
   6  * Implementation of the Notifier_i class. This class is the servant
   7  * object for the callback quoter server.
   8  *
   9  *  @author Kirthika Parameswaran <kirthika@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "Notifier_i.h"
  15
  16
  17 Notifier_i::Notifier_i (void)
  18   : notifier_exited_(0)
  19 {
  20   // No-op
  21 }
  22
  23 Notifier_i::~Notifier_i (void)
  24 {
  25   // No-op
  26 }
  27
  28 // Register a distributed callback handler that is invoked when the
  29 // given stock reaches the desired threshold value.
  30
  31 void
  32 Notifier_i::register_callback (const char *stock_name,
  33                                CORBA::Long threshold_value,
  34                                Callback_Quoter::Consumer_ptr consumer_handler)
  35 {
  36   // Store the client information.
  37   Consumer_Data consumer_data;
  38
  39   // Necessary to make another copy of the consumer_handler using
  40   // <_duplicate> so that we dont lose the consumer object reference
  41   // after the method invocation is done.
  42   consumer_data.consumer_ =
  43     Callback_Quoter::Consumer::_duplicate (consumer_handler);
  44
  45   consumer_data.desired_value_= threshold_value;
  46
  47   CONSUMERS *consumers = 0;
  48
  49   // The consumer_map consists of the stockname and various consumers
  50   // with their threshold values. To register a consumer into this
  51   // map, first the stockname is matched with an existing one (if any)
  52   // and the consumer and the threshold value is attached. Else, a new
  53   // entry is created for the stockname.
  54
  55   if (this->consumer_map_.find (stock_name, consumers) == 0)
  56     {
  57      if ( consumers->insert (consumer_data) == -1)
  58        throw Callback_Quoter::Invalid_Stock (
  59          "Insertion failed! Invalid Stock!\n");
  60      else
  61       ACE_DEBUG ((LM_DEBUG,
  62                   "Inserted map entry: stockname %s threshold %d",
  63                   stock_name,
  64                   threshold_value));
  65     }
  66   else
  67     {
  68       // the unbounded set entry is created.
  69       ACE_NEW_THROW_EX (consumers, CONSUMERS, CORBA::NO_MEMORY ());
  70
  71       // When a new entry is tried to be inserted into the unbounded set and it
  72       // fails an exception is raised.
  73       if (consumers->insert (consumer_data) == -1)
  74         throw Callback_Quoter::Invalid_Stock (
  75           "Insertion failed! Invalid Stock!\n");
  76
  77       // The bond between the stockname <hash_key> and the consumers <hash_value>
  78       // is fused.
  79       if (this->consumer_map_.bind (stock_name, consumers) == -1)
  80          ACE_ERROR ((LM_ERROR,
  81                    "register_callback: Bind failed!/n"));
  82       else
  83         ACE_DEBUG ((LM_DEBUG,
  84                     "new map entry: stockname %s threshold %d\n",
  85                     stock_name,
  86                     threshold_value));
  87     }
  88 }
  89
  90 // Obtain a pointer to the orb.
  91
  92 void
  93 Notifier_i::orb (CORBA::ORB_ptr orb)
  94 {
  95   this->orb_ = CORBA::ORB::_duplicate (orb);
  96 }
  97
  98 // Remove the client handler.
  99
 100 void
 101 Notifier_i::unregister_callback (Callback_Quoter::Consumer_ptr consumer)
 102 {
 103   // The consumer_map consists of a map of stocknames with consumers
 104   // and their threshold values attached to it. To unregister a
 105   // consumer it is necessary to remove that entry from the
 106   // map. Hence, the map is iterated till the consumer entry to be
 107   // removed is found and then removed from the map.
 108
 109   // Check to see whether the hash_map still exists. Chances are there
 110   // that the notifier has exited closing the hash map.
 111   if (notifier_exited_ == 1)
 112     return;
 113
 114   for (CONSUMER_MAP::ITERATOR iter = this->consumer_map_.begin ();
 115        iter != this->consumer_map_.end ();
 116        ++iter)
 117     {
 118       // The *iter is nothing but the stockname + unbounded set of
 119       // consumers+threshold values, i.e a ACE_Hash_Map_Entry.
 120
 121        Consumer_Data consumer_to_remove;
 122
 123        consumer_to_remove.consumer_ =
 124          Callback_Quoter::Consumer::_duplicate (consumer);
 125
 126        // int_id is a member of the ACE_Hash_Map_Entry.  The remove
 127        // method will do a find internally using operator == which
 128        // will check only the consumer pointers.  If match found it
 129        // will be removed from the set. If the consumer cannot be
 130        // removed an exception is raised.
 131
 132        if ((*iter).int_id_->remove (consumer_to_remove) == -1)
 133          throw Callback_Quoter::Invalid_Handle (
 134            "Unregistration failed! Invalid Consumer Handle!\n");
 135        else
 136         ACE_DEBUG ((LM_DEBUG,
 137                     "unregister_callback:consumer removed\n"));
 138     }
 139 }
 140
 141 // Gets the market status and sends the information to the consumer
 142 // who is interested in it.
 143
 144 void
 145 Notifier_i::market_status (const char *stock_name,
 146                            CORBA::Long stock_value)
 147 {
 148   ACE_DEBUG ((LM_DEBUG,
 149               "Notifier_i:: The stockname is %s with price %d\n",
 150               stock_name,
 151               stock_value));
 152
 153   CONSUMERS *consumers = 0;
 154
 155   if (this->consumer_map_.find (stock_name, consumers) == 0)
 156     {
 157       // Go through the list of <Consumer_Data> to find which
 158       // registered client wants to be notified.
 159
 160       for (CONSUMERS::ITERATOR iter = consumers->begin ();
 161            iter != consumers->end ();
 162            ++iter)
 163         {
 164           // Check whether the stockname is equal before proceeding
 165           // further.
 166           if (stock_value >= (*iter).desired_value_)
 167             {
 168               Callback_Quoter::Info interested_consumer_data;
 169
 170               interested_consumer_data.stock_name =
 171                 CORBA::string_dup (stock_name);
 172               interested_consumer_data.value =
 173                 stock_value;
 174
 175               ACE_DEBUG ((LM_DEBUG,
 176                           "pushing information to consumer\n"));
 177
 178               // The status desired by the consumer is then passed to
 179               // it.
 180               (*iter).consumer_->push (interested_consumer_data);
 181             }
 182         }
 183     }
 184   else
 185     ACE_DEBUG ((LM_DEBUG,
 186                 " Stock Not Present!\n"));
 187   // Raising an exception caused problems as they were caught by the Market daemon
 188   // who exited prematurely.
 189
 190 }
 191
 192 void
 193 Notifier_i::shutdown (void)
 194 {
 195   if ( this->consumer_map_.close () > 0)
 196     ACE_ERROR ((LM_ERROR,
 197                 "Consumer_map_close error!\n"));
 198   else
 199   // This marks the exit of the notifier. This should be taken care of
 200   // before the consumer tries to unregister after the notifier quits.
 201   notifier_exited_ = 1;
 202
 203   ACE_DEBUG ((LM_DEBUG,
 204               "The Callback Quoter server is shutting down...\n"));
 205
 206
 207   // Instruct the ORB to shutdown.
 208   this->orb_->shutdown ();
 209
 210 }
 211
 212 bool
 213 Notifier_i::Consumer_Data::operator== (const Consumer_Data &rhs) const
 214 {
 215   // The <_is_equivalent> function checks if the _var and _ptr objects
 216   // are the same.  NOTE: this call might not behave well on other
 217   // ORBs since <_is_equivalent> isn't guaranteed to differentiate
 218   // object references.
 219
 220   return this->consumer_->_is_equivalent (rhs.consumer_.in ());
 221 }
 222