TAO/tests/Storable/Savable.cpp

   1 #include "Savable.h"
   2 #include "tao/Storable_Base.h"
   3 #include "tao/Storable_Factory.h"
   4 #include "tao/Storable_File_Guard.h"
   5
   6 #include "ace/Auto_Ptr.h"
   7
   8 const int Savable::bytes_size_max = 128;
   9
  10 class Savable_File_Guard: public TAO::Storable_File_Guard
  11 {
  12 public:
  13
  14   Savable_File_Guard (Savable & savable, Method_Type method_type);
  15
  16   ~Savable_File_Guard ();
  17
  18   virtual void set_object_last_changed (const time_t & time);
  19
  20   virtual time_t get_object_last_changed ();
  21
  22   virtual int load_from_stream ();
  23
  24   virtual bool is_loaded_from_stream ();
  25
  26   virtual TAO::Storable_Base * create_stream (const char * mode);
  27
  28 private:
  29   Savable & savable_;
  30 };
  31
  32 Savable_File_Guard::Savable_File_Guard (Savable & savable,
  33                                         Method_Type method_type)
  34   : TAO::Storable_File_Guard(false)
  35   , savable_(savable)
  36 {
  37   try
  38     {
  39       this->init(method_type);
  40     }
  41   catch (TAO::Storable_Read_Exception &)
  42     {
  43       throw Savable_Exception();
  44     }
  45 }
  46
  47 Savable_File_Guard::~Savable_File_Guard ()
  48 {
  49   this->release ();
  50 }
  51
  52 void
  53 Savable_File_Guard::set_object_last_changed (const time_t & time)
  54 {
  55   savable_.last_changed_ = time;
  56 }
  57
  58 time_t
  59 Savable_File_Guard::get_object_last_changed ()
  60 {
  61   return savable_.last_changed_;
  62 }
  63
  64 int
  65 Savable_File_Guard::load_from_stream ()
  66 {
  67   savable_.read (this->peer ());
  68   savable_.loaded_from_stream_ = true;
  69   this->peer ().rewind ();
  70   if (this->peer ().good ())
  71     return 0;
  72   else
  73     return -1;
  74 }
  75
  76 bool
  77 Savable_File_Guard::is_loaded_from_stream ()
  78 {
  79   return savable_.loaded_from_stream_;
  80 }
  81
  82 TAO::Storable_Base *
  83 Savable_File_Guard::create_stream (const char * mode)
  84 {
  85   return savable_.storable_factory_.create_stream ("test.dat", mode);
  86 }
  87
  88 typedef TAO::Storable_File_Guard SFG;
  89
  90 Savable::Savable (TAO::Storable_Factory & storable_factory)
  91   : storable_factory_(storable_factory)
  92   , loaded_from_stream_ (false)
  93 {
  94
  95   for (int index = 0; index < 2; ++index)
  96     {
  97       this->i_[index] = 0;
  98       this->ui_[index] = 0;
  99       this->bytes_size_[index] = 0;
 100       this->bytes_[index] = new char [this->bytes_size_max];
 101       for (int i = 0; i < this->bytes_size_max; ++i)
 102         {
 103           this->bytes_[index][i] = ACE_CHAR_MAX;
 104         }
 105     }
 106
 107   ACE_Auto_Ptr<TAO::Storable_Base>
 108     stream (storable_factory_.create_stream("test.dat", "r"));
 109   if (stream->exists ())
 110     {
 111       Savable_File_Guard fg(*this, SFG::CREATE_WITH_FILE);
 112     }
 113   else
 114     {
 115       Savable_File_Guard fg(*this, SFG::CREATE_WITHOUT_FILE);
 116       this->write (fg.peer ());
 117     }
 118 }
 119
 120 Savable::~Savable ()
 121 {
 122   for (int index = 0; index < 2; ++index)
 123     {
 124       delete []this->bytes_[index];
 125     }
 126 }
 127
 128 bool
 129 Savable::is_loaded_from_stream ()
 130 {
 131   return this->loaded_from_stream_;
 132 }
 133
 134 void
 135 Savable::read (TAO::Storable_Base & stream)
 136 {
 137   stream.rewind ();
 138
 139   for (int index = 0; index < 2; ++index)
 140     {
 141       stream >> this->string_[index];
 142       stream >> this->i_[index];
 143       stream >> this->ui_[index];
 144       stream >> this->bytes_size_[index];
 145       stream.read (this->bytes_size_[index], this->bytes_[index]);
 146     }
 147 }
 148
 149 void
 150 Savable::write (TAO::Storable_Base & stream)
 151 {
 152   stream.rewind ();
 153
 154   for (int index = 0; index < 2; ++index)
 155     {
 156       stream << this->string_[index];
 157       stream << this->i_[index];
 158       stream << this->ui_[index];
 159       stream << this->bytes_size_[index];
 160       stream.write (this->bytes_size_[index], this->bytes_[index]);
 161     }
 162
 163   stream.flush ();
 164 }
 165
 166 void
 167 Savable::string_set (int index, const ACE_CString &s)
 168 {
 169   Savable_File_Guard fg(*this, SFG::MUTATOR);
 170   this->string_[index] = s;
 171   this->write (fg.peer ());
 172 }
 173
 174 const ACE_CString &
 175 Savable::string_get (int index)
 176 {
 177   Savable_File_Guard fg(*this, SFG::ACCESSOR);
 178   return this->string_[index];
 179 }
 180
 181 void
 182 Savable::int_set (int index, int i)
 183 {
 184   Savable_File_Guard fg(*this, SFG::MUTATOR);
 185   this->i_[index] = i;
 186   this->write (fg.peer ());
 187 }
 188
 189 int
 190 Savable::int_get (int index)
 191 {
 192   Savable_File_Guard fg(*this, SFG::ACCESSOR);
 193   return this->i_[index];
 194 }
 195
 196 void
 197 Savable::unsigned_int_set (int index, unsigned int ui)
 198 {
 199   Savable_File_Guard fg(*this, SFG::MUTATOR);
 200   this->ui_[index] = ui;
 201   this->write (fg.peer ());
 202 }
 203
 204 unsigned int
 205 Savable::unsigned_int_get (int index)
 206 {
 207   Savable_File_Guard fg(*this, SFG::ACCESSOR);
 208   return this->ui_[index];
 209 }
 210
 211 void
 212 Savable::bytes_set (int index, int size, char * bytes)
 213 {
 214   Savable_File_Guard fg(*this, SFG::MUTATOR);
 215   this->bytes_size_[index] = size;
 216   for (int i = 0; i < this->bytes_size_[index]; ++i)
 217     {
 218       this->bytes_[index][i] = bytes[i];
 219     }
 220   this->write (fg.peer ());
 221 }
 222
 223 int
 224 Savable::bytes_get (int index, char * bytes)
 225 {
 226   Savable_File_Guard fg(*this, SFG::ACCESSOR);
 227   for (int i = 0; i < this->bytes_size_[index]; ++i)
 228     {
 229       bytes[i] = this->bytes_[index][i];
 230     }
 231   return this->bytes_size_[index];
 232 }