TAO/docs/tutorials/Quoter/RTCORBA/Stock_Database.tpp

   1 #ifndef STOCK_DATABASE_TPP
   2 #define STOCK_DATABASE_TPP
   3 // local headers
   4 #include "Stock_Database.h"
   5
   6 // ACE headers
   7 #include <ace/OS_NS_unistd.h>
   8 #include <ace/UUID.h>
   9
  10 #include <fstream>
  11 #include <vector>
  12 template <typename CALLBACK>
  13 struct Map_Init
  14 {
  15   Map_Init (typename Stock_Database<CALLBACK>::Stock_Map &map)
  16     : map_ (map)
  17   {
  18   }
  19
  20   void operator () (const typename Stock_Database<CALLBACK>::Init_Map::value_type &item)
  21   {
  22     typename Stock_Database<CALLBACK>::StockInfo stock_info (item.first.c_str ());
  23
  24     // If the initial value is nonzero, use that - otherwise, use a number
  25     // between 0 and 100
  26     stock_info.low_ =
  27       stock_info.last_ =
  28       stock_info.high_ = item.second ? item.second : ACE_OS::rand () % 100;
  29
  30     map_[item.first] = stock_info;
  31   }
  32
  33   typename Stock_Database<CALLBACK>::Stock_Map &map_;
  34 };
  35
  36 // Stock_Database
  37 template <typename CALLBACK>
  38 Stock_Database<CALLBACK>::Stock_Database (u_int rate)
  39   : rate_ (rate),
  40     active_ (false)
  41 {
  42   Init_Map map;
  43   map["IBM"] = 0;
  44   map["MSFT"] = 0;
  45   map["INTEL"] = 0;
  46
  47   std::for_each (map.begin (),
  48                  map.end (),
  49                  Map_Init<CALLBACK> (this->stock_map_));
  50 }
  51
  52 template <typename CALLBACK>
  53 Stock_Database<CALLBACK>::Stock_Database (const char *file, u_int rate)
  54   : filename_ (file),
  55     rate_ (rate),
  56     active_ (false)
  57 {
  58   this->handle_signal (0, 0, 0);
  59 }
  60
  61 template <typename CALLBACK>
  62 Stock_Database<CALLBACK>::Stock_Database (const Init_Map &stockmap,
  63                                           u_int rate)
  64   : rate_ (rate),
  65     active_ (false)
  66 {
  67   std::for_each (stockmap.begin (),
  68                  stockmap.end (),
  69                  Map_Init<CALLBACK> (this->stock_map_));
  70 }
  71
  72 // get_stock_info
  73 template <typename CALLBACK>
  74 typename Stock_Database<CALLBACK>::StockInfo
  75 Stock_Database<CALLBACK>::get_stock_info(const char *name)
  76 {
  77   ACE_READ_GUARD_RETURN (ACE_RW_Thread_Mutex,
  78                          guard,
  79                          this->lock_,
  80                          StockInfo ("Error"));
  81
  82   // Locate the <stock_name> in the database.
  83   ACE_DEBUG ((LM_DEBUG,
  84               "*** message: searching the stock_map_ for the stock_name\n"));
  85
  86   typename Stock_Map::iterator iter = this->stock_map_.find (std::string (name));
  87
  88   if (iter == this->stock_map_.end ())
  89     throw Invalid_Stock ();
  90
  91   ACE_DEBUG ((LM_DEBUG, "*** message: returning stock_info to the client\n"));
  92
  93   return iter->second;
  94 }
  95
  96 template <typename CALLBACK>
  97 typename Stock_Database<CALLBACK>::Cookie
  98 Stock_Database<CALLBACK>::register_callback (CALLBACK &obj)
  99 {
 100   ACE_Utils::UUID uuid;
 101   ACE_Utils::UUID_GENERATOR::instance ()->generate_UUID (uuid);
 102
 103   this->callbacks_[uuid.to_string ()->c_str ()] = &obj;
 104
 105   return uuid.to_string ()->c_str ();
 106 }
 107
 108 template <typename CALLBACK>
 109 void
 110 Stock_Database<CALLBACK>::update_rate (u_int rate)
 111 {
 112   this->rate_ = rate;
 113 }
 114
 115 template <typename CALLBACK>
 116 void
 117 Stock_Database<CALLBACK>::start (void)
 118 {
 119   if (!this->active_)
 120     { // Double checked locking
 121       ACE_WRITE_GUARD (ACE_RW_Thread_Mutex,
 122                        guard,
 123                        this->lock_);
 124       if (!this->active_)
 125         {
 126           this->active_ = true;
 127           this->activate (THR_NEW_LWP | THR_JOINABLE, 1);
 128         }
 129     }
 130 }
 131
 132 template <typename CALLBACK>
 133 void
 134 Stock_Database<CALLBACK>::stop (void)
 135 {
 136   ACE_WRITE_GUARD (ACE_RW_Thread_Mutex,
 137                           guard,
 138                           this->lock_);
 139
 140   this->active_ = false;
 141 }
 142
 143 template <typename CALLBACK>
 144 int
 145 Stock_Database<CALLBACK>::handle_signal (int,
 146                                          siginfo_t *,
 147                                          ucontext_t *)
 148 {
 149   ACE_WRITE_GUARD_RETURN (ACE_RW_Thread_Mutex,
 150                           guard,
 151                           this->lock_,
 152                           -1);
 153
 154   std::ifstream input (this->filename_.c_str ());
 155
 156   std::string name;
 157   u_int value = 0;
 158
 159   typename Stock_Database<CALLBACK>::Init_Map map;
 160
 161   while (input.good ())
 162     {
 163       input >> name;
 164       input >> value;
 165       map[name] = value;
 166     }
 167
 168   input.close ();
 169
 170   std::for_each (map.begin (),
 171                  map.end (),
 172                  Map_Init<CALLBACK> (this->stock_map_));
 173
 174   return 0;
 175 }
 176
 177
 178 template <typename CALLBACK>
 179 struct Stock_Updater
 180 {
 181   void operator () (typename Stock_Database<CALLBACK>::Stock_Map::value_type &item)
 182   {
 183     // Determine if the stock has changed.
 184     if (ACE_OS::rand () % 2)
 185       return; // Nope! On to the next!
 186
 187     changed_.push_back (item.first);
 188
 189     // Determine the amount of change of the stock. We will
 190     // only permit a 5 point change at a time in either direction
 191     int delta = ACE_OS::rand () % 10 - 5;
 192
 193     // We don't want negative stock values!
 194     if (item.second.last_ <= delta)
 195       delta *= -1;
 196
 197     // Calculate the new values for the stock.
 198     item.second.last_ += delta;
 199
 200     if (item.second.last_ < item.second.low_)
 201       item.second.low_ = item.second.last_;
 202     else if (item.second.last_ > item.second.high_)
 203       item.second.high_ = item.second.last_;
 204   }
 205
 206   void operator () (typename Stock_Database<CALLBACK>::Callback_Map::value_type &item)
 207   {
 208     (*item.second)  (changed_);
 209   }
 210
 211 private:
 212   std::vector <std::string> changed_;
 213 };
 214
 215 template <typename CALLBACK>
 216 int
 217 Stock_Database<CALLBACK>::svc (void)
 218 {
 219   ACE_DEBUG ((LM_DEBUG, "tock!\n"));
 220
 221   while (this->active_)
 222     {
 223       {
 224         // Init our functor
 225         Stock_Updater<CALLBACK> updater;
 226
 227         { // Control the scope of our mutex to avoid deadlock.
 228           ACE_WRITE_GUARD_RETURN (ACE_RW_Thread_Mutex,
 229                                   guard,
 230                                   this->lock_,
 231                                   -1);
 232
 233           updater = std::for_each (this->stock_map_.begin (),
 234                                    this->stock_map_.end (),
 235                                    updater);
 236         }
 237
 238         // Update stock prices
 239         // notify callbacks
 240         std::for_each (this->callbacks_.begin (),
 241                        this->callbacks_.end (),
 242                        updater);
 243       }
 244
 245       // Sleep for one second.
 246       ACE_OS::sleep (this->rate_);
 247     }
 248
 249   return 0;
 250 }
 251
 252 #endif /* STOCK_DATABASE_TPP */