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 () 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 () const
  36 {
  37   return this->data_;
  38 }
  39
  40 size_t
  41 JAWS_Cache_Object::size () const
  42 {
  43   return this->size_;
  44 }
  45
  46 unsigned int
  47 JAWS_Cache_Object::count () const
  48 {
  49   return this->count_i ();
  50 }
  51
  52 int
  53 JAWS_Cache_Object::acquire ()
  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 ()
  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 () const
  68 {
  69   return this->last_access_;
  70 }
  71
  72 time_t
  73 JAWS_Cache_Object::first_access () const
  74 {
  75   return this->first_access_;
  76 }
  77
  78 unsigned int
  79 JAWS_Cache_Object::priority () const
  80 {
  81   return this->priority_i ();
  82 }
  83
  84 void *
  85 JAWS_Cache_Object::heap_item () 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 ()
 105 {
 106 }
 107
 108 ACE_Lock &
 109 JAWS_Referenced_Cache_Object::lock ()
 110 {
 111   return this->lock_adapter_;
 112 }
 113
 114 unsigned int
 115 JAWS_Referenced_Cache_Object::count_i () 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 ()
 125 {
 126   return this->count_.acquire_read ();
 127 }
 128
 129 int
 130 JAWS_Referenced_Cache_Object::release_i ()
 131 {
 132   return this->count_.release ();
 133 }
 134
 135 unsigned int
 136 JAWS_Referenced_Cache_Object::priority_i () 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 JAWS_Counted_Cache_Object::
 150 JAWS_Counted_Cache_Object (const void *data, size_t size)
 151   : JAWS_Cache_Object (data, size),
 152     count_ (0),
 153     new_count_ (0),
 154     lock_adapter_ (lock_)
 155 {
 156 }
 157
 158 JAWS_Counted_Cache_Object::~JAWS_Counted_Cache_Object ()
 159 {
 160 }
 161
 162 ACE_Lock &
 163 JAWS_Counted_Cache_Object::lock ()
 164 {
 165   return this->lock_adapter_;
 166 }
 167
 168 unsigned int
 169 JAWS_Counted_Cache_Object::count_i () const
 170 {
 171   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, g ,this->lock_, 0);
 172
 173   return this->count_;
 174 }
 175
 176 int
 177 JAWS_Counted_Cache_Object::acquire_i ()
 178 {
 179   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, g ,this->lock_, 0);
 180
 181   ++this->new_count_;
 182   return 0;
 183 }
 184
 185 int
 186 JAWS_Counted_Cache_Object::release_i ()
 187 {
 188   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, g ,this->lock_, 0);
 189
 190   --this->new_count_;
 191   this->count_ = this->new_count_;
 192   return 0;
 193 }
 194
 195 unsigned int
 196 JAWS_Counted_Cache_Object::priority_i () const
 197 {
 198   return this->count_i ();
 199 }
 200
 201 JAWS_Cache_Object_Factory::JAWS_Cache_Object_Factory (ACE_Allocator *alloc)
 202   : allocator_ (alloc)
 203 {
 204   if (this->allocator_ == 0)
 205     this->allocator_ = ACE_Allocator::instance ();
 206 }
 207
 208 JAWS_Cache_Object_Factory::~JAWS_Cache_Object_Factory ()
 209 {
 210 }
 211
 212 int
 213 JAWS_Cache_Object_Factory::open (ACE_Allocator *alloc)
 214 {
 215   this->allocator_ = alloc;
 216
 217   if (this->allocator_ == 0)
 218     this->allocator_ = ACE_Allocator::instance ();
 219
 220   return 0;
 221 }
 222
 223 JAWS_Referenced_Cache_Object_Factory
 224 ::JAWS_Referenced_Cache_Object_Factory (ACE_Allocator *alloc)
 225   : JAWS_Cache_Object_Factory (alloc)
 226 {
 227 }
 228
 229 JAWS_Referenced_Cache_Object_Factory
 230 ::~JAWS_Referenced_Cache_Object_Factory ()
 231 {
 232 }
 233
 234 JAWS_Cache_Object *
 235 JAWS_Referenced_Cache_Object_Factory::create (const void *data, size_t size)
 236 {
 237   JAWS_Referenced_Cache_Object *obj;
 238
 239   size_t obj_size = sizeof (JAWS_Referenced_Cache_Object);
 240   ACE_NEW_MALLOC_RETURN (obj,
 241                          (JAWS_Referenced_Cache_Object *)
 242                          this->allocator_->malloc (obj_size),
 243                          JAWS_Referenced_Cache_Object (data, size), 0);
 244
 245   return obj;
 246 }
 247
 248 void
 249 JAWS_Referenced_Cache_Object_Factory::destroy (JAWS_Cache_Object *obj)
 250 {
 251   JAWS_Referenced_Cache_Object *rco = (JAWS_Referenced_Cache_Object *) obj;
 252   ACE_DES_FREE (rco, this->allocator_->free, JAWS_Referenced_Cache_Object);
 253 }
 254
 255 JAWS_Counted_Cache_Object_Factory
 256 ::JAWS_Counted_Cache_Object_Factory (ACE_Allocator *alloc)
 257   : JAWS_Cache_Object_Factory (alloc)
 258 {
 259 }
 260
 261 JAWS_Counted_Cache_Object_Factory
 262 ::~JAWS_Counted_Cache_Object_Factory ()
 263 {
 264 }
 265
 266 JAWS_Cache_Object *
 267 JAWS_Counted_Cache_Object_Factory::create (const void *data, size_t size)
 268 {
 269   JAWS_Counted_Cache_Object *obj;
 270
 271   size_t obj_size = sizeof (JAWS_Counted_Cache_Object);
 272   ACE_NEW_MALLOC_RETURN (obj,
 273                          (JAWS_Counted_Cache_Object *)
 274                          this->allocator_->malloc (obj_size),
 275                          JAWS_Counted_Cache_Object (data, size), 0);
 276
 277   return obj;
 278 }
 279
 280 void
 281 JAWS_Counted_Cache_Object_Factory::destroy (JAWS_Cache_Object *obj)
 282 {
 283   JAWS_Counted_Cache_Object *cco = (JAWS_Counted_Cache_Object *) obj;
 284   ACE_DES_FREE (cco, this->allocator_->free, JAWS_Counted_Cache_Object);
 285 }
 286