TAO/examples/Persistent_Grid/Grid_i.cpp

   1 // -*- C++ -*-
   2 #include "Grid_i.h"
   3
   4 // Default constructor.
   5
   6 Grid_i::Grid_i ()
   7   : width_ (0),
   8     height_ (0),
   9     array_ (0)
  10 {
  11   //no-op
  12 }
  13
  14 //  Constructor.
  15
  16 Grid_i::Grid_i (CORBA::Short x,
  17                 CORBA::Short y,
  18                 pool_t *mem_pool)
  19   : width_ (x),
  20     height_ (y),
  21     array_ (0),
  22     pool_t_ (0)
  23 {
  24   // First try to locate the matrix in the pool. If it is there then
  25   // it has already been created. In such a case we just get that
  26   // memory and assign it to array_
  27
  28   void *tmp_array (0);
  29
  30   if (mem_pool->find ("Array", tmp_array) != -1)
  31     {
  32       array_ = reinterpret_cast <CORBA::Long **> (tmp_array);
  33     }
  34   else
  35     {
  36       // Allocate memory for the matrix.
  37       ACE_ALLOCATOR (array_,
  38                      static_cast<CORBA::Long **> (mem_pool->malloc (y * sizeof (CORBA::Long *))));
  39       //array_ = (CORBA::Long **) mem_pool->malloc (y * sizeof (CORBA::Long *));
  40
  41       if (array_ != 0)
  42         {
  43           for (int ctr = 0; ctr < y; ctr++)
  44             {
  45               ACE_ALLOCATOR (array_[ctr],
  46                              static_cast<CORBA::Long *> (mem_pool->malloc (x *
  47                                                                 sizeof (CORBA::Long ))));
  48
  49               //array_[ctr] = (CORBA::Long *)mem_pool->malloc (x *
  50               //                                            sizeof (CORBA::Long));
  51             }
  52
  53           mem_pool->bind ("Array", array_);
  54         }
  55     }
  56
  57 }
  58
  59 // Default destructor.
  60
  61 Grid_i::~Grid_i ()
  62 {
  63 }
  64
  65 //  Set a value in the grid.
  66
  67 void
  68 Grid_i::set (CORBA::Short x,
  69              CORBA::Short y,
  70              CORBA::Long value)
  71 {
  72   if (x < 0
  73       || y < 0
  74       || x >= width_
  75       || y >= height_)
  76     throw Grid::RANGE_ERROR ();
  77   else
  78     array_[x][y] = value;
  79 }
  80
  81 //  Get a value from  the grid.
  82
  83 CORBA::Long
  84 Grid_i::get (CORBA::Short x,
  85              CORBA::Short y)
  86 {
  87   if (x < 0
  88       || y < 0
  89       || x >= width_
  90       || y >= height_)
  91     throw Grid::RANGE_ERROR ();
  92   else
  93     return array_[x][y];
  94 }
  95
  96 // Access methods.
  97
  98 CORBA::Short
  99 Grid_i::width ()
 100 {
 101   return this->width_;
 102 }
 103
 104 CORBA::Short
 105 Grid_i::height ()
 106 {
 107   return this->height_;
 108 }
 109
 110 void
 111 Grid_i::width (CORBA::Short x)
 112 {
 113   this->width_ = x;
 114 }
 115
 116 void
 117 Grid_i::height (CORBA::Short y)
 118 {
 119   this->height_ = y;
 120 }
 121
 122 // Destroy the grid
 123 void
 124 Grid_i::destroy ( )
 125 {
 126   // Delete the array.
 127   for (int i = 0; i < height_; i++)
 128     this->pool_t_->free (array_[i]);
 129
 130   //  delete [] array_;
 131   this->pool_t_->free (array_);
 132
 133   ACE_DEBUG ((LM_DEBUG,
 134               " (%P|%t) %s\n",
 135               "Grid has been destroyed"));
 136 }
 137
 138 void
 139 Grid_i::set_pool (pool_t *pool)
 140 {
 141   this->pool_t_ = pool;
 142 }
 143 // Constructor
 144
 145 Grid_Factory_i::Grid_Factory_i ()
 146   : orb_ (0),
 147     pool_name_ (0),
 148     pool_t_ (0)
 149 {
 150 }
 151
 152 // Destructor
 153
 154 Grid_Factory_i::~Grid_Factory_i ()
 155 {
 156   delete this->pool_t_;
 157 }
 158
 159 // Make a <Grid>.
 160
 161 Grid_ptr
 162 Grid_Factory_i::make_grid (CORBA::Short width,
 163                            CORBA::Short height)
 164 {
 165   ACE_DEBUG ((LM_DEBUG,
 166               " (%P|%t) Making a new Grid\n"));
 167
 168   // Set a default value for width.
 169   if (width <= 0)
 170     width = Grid_Factory::DEFAULT_WIDTH;
 171
 172   // Set a default value for height.
 173   if (height <= 0)
 174     height = Grid_Factory::DEFAULT_HEIGHT;
 175
 176   // Get a memory pool
 177   ACE_NEW_THROW_EX (pool_t_,
 178                     pool_t (pool_name_),
 179                     CORBA::NO_MEMORY ());
 180
 181   //  pool_t_ = new pool_t (pool_name_);
 182
 183   // This attempts to create a new Grid_i and throws an exception and
 184   // returns a null value if it fails
 185   int prev_no = errno;
 186   Grid_i *grid_ptr = new Grid_i (width,
 187                                  height,
 188                                  pool_t_);
 189   if (errno == ENOMEM)
 190     throw CORBA::NO_MEMORY ();
 191
 192   errno = prev_no;
 193
 194   grid_ptr->set_pool (pool_t_);
 195
 196   // Register the Grid pointer.
 197   return grid_ptr->_this ();
 198 }
 199
 200 // Set the ORB pointer.
 201
 202 void
 203 Grid_Factory_i::orb (CORBA::ORB_ptr o)
 204 {
 205   this->orb_ = CORBA::ORB::_duplicate (o);
 206 }
 207
 208 // Shutdown.
 209 void
 210 Grid_Factory_i::shutdown ()
 211 {
 212   ACE_DEBUG ((LM_DEBUG,
 213               " (%P|%t) %s\n",
 214               "Grid Factory is shutting down"));
 215
 216   // Instruct the ORB to shutdown.
 217   this->orb_->shutdown ();
 218 }
 219
 220 void
 221 Grid_Factory_i::cleanup ()
 222 {
 223   const char *name = "Array";
 224
 225   if (this->pool_t_->unbind (name) == -1)
 226     ACE_DEBUG ((LM_DEBUG,
 227                 "\n Failed to unbind "));
 228 }
 229
 230 void
 231 Grid_Factory_i::pool_name (const ACE_TCHAR *name)
 232 {
 233   this->pool_name_ = ACE_OS::strdup (name);
 234 }