ACE/apps/JAWS2/JAWS/Cache_Object.cpp

   1 #include "JAWS/Cache_Object.h"
   2
   3 #include "ace/Malloc_Base.h"
   4 #include "ace/Guard_T.h"
   5 #include "ace/OS_NS_time.h"
   6
   7 JAWS_Cache_Object::JAWS_Cache_Object (const void *data, size_t size)
   8   : internal_ (0),
   9     data_ (data),
  10     size_ (size)
  11 {
  12   this->first_access_ = ACE_OS::time ((time_t *)0);
  13   this->new_last_access_ = this->last_access_ = this->first_access_;
  14 }
  15
  16 JAWS_Cache_Object::~JAWS_Cache_Object ()
  17 {
  18   this->data_ = 0;
  19   this->size_ = 0;
  20 }
  21
  22 void *
  23 JAWS_Cache_Object::internal (void) const
  24 {
  25   return this->internal_;
  26 }
  27
  28 void
  29 JAWS_Cache_Object::internal (void *item)
  30 {
  31   this->internal_ = item;
  32 }
  33
  34 const void *
  35 JAWS_Cache_Object::data (void) const
  36 {
  37   return this->data_;
  38 }
  39
  40 size_t
  41 JAWS_Cache_Object::size (void) const
  42 {
  43   return this->size_;
  44 }
  45
  46 unsigned int
  47 JAWS_Cache_Object::count (void) const
  48 {
  49   return this->count_i ();
  50 }
  51
  52 int
  53 JAWS_Cache_Object::acquire (void)
  54 {
  55   this->new_last_access_ = ACE_OS::time ((time_t *)0);
  56   return this->acquire_i ();
  57 }
  58
  59 int
  60 JAWS_Cache_Object::release (void)
  61 {
  62   this->last_access_ = this->new_last_access_;
  63   return this->release_i ();
  64 }
  65
  66 time_t
  67 JAWS_Cache_Object::last_access (void) const
  68 {
  69   return this->last_access_;
  70 }
  71
  72 time_t
  73 JAWS_Cache_Object::first_access (void) const
  74 {
  75   return this->first_access_;
  76 }
  77
  78 unsigned int
  79 JAWS_Cache_Object::priority (void) const
  80 {
  81   return this->priority_i ();
  82 }
  83
  84 void *
  85 JAWS_Cache_Object::heap_item (void) const
  86 {
  87   return this->heap_item_;
  88 }
  89
  90 void
  91 JAWS_Cache_Object::heap_item (void *item)
  92 {
  93   this->heap_item_ = item;
  94 }
  95
  96
  97 JAWS_Referenced_Cache_Object::
  98 JAWS_Referenced_Cache_Object (const void *data, size_t size)
  99   : JAWS_Cache_Object (data, size),
 100     lock_adapter_ (count_)
 101 {
 102 }
 103
 104 JAWS_Referenced_Cache_Object::~JAWS_Referenced_Cache_Object (void)
 105 {
 106 }
 107
 108 ACE_Lock &
 109 JAWS_Referenced_Cache_Object::lock (void)
 110 {
 111   return this->lock_adapter_;
 112 }
 113
 114 unsigned int
 115 JAWS_Referenced_Cache_Object::count_i (void) const
 116 {
 117   if (this->count_.tryacquire_write () == 0)
 118     return 0;
 119
 120   return 1;
 121 }
 122
 123 int
 124 JAWS_Referenced_Cache_Object::acquire_i (void)
 125 {
 126   return this->count_.acquire_read ();
 127 }
 128
 129 int
 130 JAWS_Referenced_Cache_Object::release_i (void)
 131 {
 132   return this->count_.release ();
 133 }
 134
 135 unsigned int
 136 JAWS_Referenced_Cache_Object::priority_i (void) const
 137 {
 138   unsigned int priority = ~(0U);
 139   double delta
 140     = ACE_OS::difftime (this->last_access (), this->first_access ());
 141
 142   if (delta >= 0.0 && delta < ~(0U))
 143     priority = (unsigned) delta;
 144
 145   return priority;
 146 }
 147
 148
 149
 150 JAWS_Counted_Cache_Object::
 151 JAWS_Counted_Cache_Object (const void *data, size_t size)
 152   : JAWS_Cache_Object (data, size),
 153     count_ (0),
 154     new_count_ (0),
 155     lock_adapter_ (lock_)
 156 {
 157 }
 158
 159 JAWS_Counted_Cache_Object::~JAWS_Counted_Cache_Object (void)
 160 {
 161 }
 162
 163 ACE_Lock &
 164 JAWS_Counted_Cache_Object::lock (void)
 165 {
 166   return this->lock_adapter_;
 167 }
 168
 169 unsigned int
 170 JAWS_Counted_Cache_Object::count_i (void) const
 171 {
 172   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, g ,this->lock_, 0);
 173
 174   return this->count_;
 175 }
 176
 177 int
 178 JAWS_Counted_Cache_Object::acquire_i (void)
 179 {
 180   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, g ,this->lock_, 0);
 181
 182   ++this->new_count_;
 183   return 0;
 184 }
 185
 186 int
 187 JAWS_Counted_Cache_Object::release_i (void)
 188 {
 189   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, g ,this->lock_, 0);
 190
 191   --this->new_count_;
 192   this->count_ = this->new_count_;
 193   return 0;
 194 }
 195
 196 unsigned int
 197 JAWS_Counted_Cache_Object::priority_i (void) const
 198 {
 199   return this->count_i ();
 200 }
 201
 202 JAWS_Cache_Object_Factory::JAWS_Cache_Object_Factory (ACE_Allocator *alloc)
 203   : allocator_ (alloc)
 204 {
 205   if (this->allocator_ == 0)
 206     this->allocator_ = ACE_Allocator::instance ();
 207 }
 208
 209 JAWS_Cache_Object_Factory::~JAWS_Cache_Object_Factory (void)
 210 {
 211 }
 212
 213 int
 214 JAWS_Cache_Object_Factory::open (ACE_Allocator *alloc)
 215 {
 216   this->allocator_ = alloc;
 217
 218   if (this->allocator_ == 0)
 219     this->allocator_ = ACE_Allocator::instance ();
 220
 221   return 0;
 222 }
 223
 224 JAWS_Referenced_Cache_Object_Factory
 225 ::JAWS_Referenced_Cache_Object_Factory (ACE_Allocator *alloc)
 226   : JAWS_Cache_Object_Factory (alloc)
 227 {
 228 }
 229
 230 JAWS_Referenced_Cache_Object_Factory
 231 ::~JAWS_Referenced_Cache_Object_Factory (void)
 232 {
 233 }
 234
 235 JAWS_Cache_Object *
 236 JAWS_Referenced_Cache_Object_Factory::create (const void *data, size_t size)
 237 {
 238   JAWS_Referenced_Cache_Object *obj;
 239
 240   size_t obj_size = sizeof (JAWS_Referenced_Cache_Object);
 241   ACE_NEW_MALLOC_RETURN (obj,
 242                          (JAWS_Referenced_Cache_Object *)
 243                          this->allocator_->malloc (obj_size),
 244                          JAWS_Referenced_Cache_Object (data, size), 0);
 245
 246   return obj;
 247 }
 248
 249 void
 250 JAWS_Referenced_Cache_Object_Factory::destroy (JAWS_Cache_Object *obj)
 251 {
 252   JAWS_Referenced_Cache_Object *rco = (JAWS_Referenced_Cache_Object *) obj;
 253   ACE_DES_FREE (rco, this->allocator_->free, JAWS_Referenced_Cache_Object);
 254 }
 255
 256 JAWS_Counted_Cache_Object_Factory
 257 ::JAWS_Counted_Cache_Object_Factory (ACE_Allocator *alloc)
 258   : JAWS_Cache_Object_Factory (alloc)
 259 {
 260 }
 261
 262 JAWS_Counted_Cache_Object_Factory
 263 ::~JAWS_Counted_Cache_Object_Factory (void)
 264 {
 265 }
 266
 267 JAWS_Cache_Object *
 268 JAWS_Counted_Cache_Object_Factory::create (const void *data, size_t size)
 269 {
 270   JAWS_Counted_Cache_Object *obj;
 271
 272   size_t obj_size = sizeof (JAWS_Counted_Cache_Object);
 273   ACE_NEW_MALLOC_RETURN (obj,
 274                          (JAWS_Counted_Cache_Object *)
 275                          this->allocator_->malloc (obj_size),
 276                          JAWS_Counted_Cache_Object (data, size), 0);
 277
 278   return obj;
 279 }
 280
 281 void
 282 JAWS_Counted_Cache_Object_Factory::destroy (JAWS_Cache_Object *obj)
 283 {
 284   JAWS_Counted_Cache_Object *cco = (JAWS_Counted_Cache_Object *) obj;
 285   ACE_DES_FREE (cco, this->allocator_->free, JAWS_Counted_Cache_Object);
 286 }
 287