Added Cache files here. Altered IO.cpp to match fix in JAWS classic

indicated by Bill Rizzi.  Altered Makefile to match.

16 files changed, 3839 insertions, 293 deletions

diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Hash_T.cpp b/apps/JAWS/PROTOTYPE/JAWS/Cache_Hash_T.cpp
new file mode 100644
index 00000000000..95be98cb02c
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Hash_T.cpp
@@ -0,0 +1,227 @@
+// $Id$
+
+#ifndef ACE_CACHE_HASH_T_CPP
+#define ACE_CACHE_HASH_T_CPP
+
+#include "JAWS/Cache_Hash_T.h"
+#include "JAWS/Hash_Bucket_T.h"
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> unsigned long
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::hash (const EXT_ID &ext_id) const
+{
+  return HASH_FUNC (ext_id) % this->size_;
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::isprime (unsigned long number) const
+{
+  unsigned long d = 3;
+
+  if (number <= 2) return (number == 2);
+
+  if (number % 2 == 0) return 0;
+
+  while (d <= number/d)
+    {
+      if (number % d == 0) return 0;
+      d += 2;
+    }
+
+  return 1;
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::new_cachebucket (size_t hash_idx)
+{
+  if (this->hashtable_[hash_idx] == 0)
+    {
+      size_t alloc_size = sizeof (CACHE_BUCKET_MANAGER);
+      ACE_NEW_MALLOC_RETURN (this->hashtable_[hash_idx],
+                             (CACHE_BUCKET_MANAGER *)
+                             this->allocator_->malloc (alloc_size),
+                             CACHE_BUCKET_MANAGER (this->allocator_), -1);
+    }
+
+  return 0;
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC>
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::ACE_Cache_Hash (ACE_Allocator *alloc,
+                                                          size_t size)
+  : allocator_ (alloc),
+    hashtable_ (0)
+{
+  while (!this->isprime (size))
+    size++;
+
+  this->size_ = size;
+
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+
+  size_t memsize = this->size_ * sizeof (CACHE_BUCKET_MANAGER *);
+
+  this->hashtable_
+    = (CACHE_BUCKET_MANAGER **) this->allocator_->malloc (memsize);
+
+  if (this->hashtable_)
+    {
+      for (size_t i = 0; i < this->size_; i++)
+        this->hashtable_[i] = 0;
+    }
+  else
+    {
+      this->size_ = 0;
+      // should indicate something is wrong to the user.
+    }
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC>
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::~ACE_Cache_Hash (void)
+{
+  if (this->hashtable_)
+    {
+      for (size_t i = 0; i < this->size_; i++)
+        {
+          if (this->hashtable_[i])
+            {
+              ACE_DES_FREE (this->hashtable_[i], this->allocator_->free,
+                            CACHE_BUCKET_MANAGER);
+              this->hashtable_[i] = 0;
+            }
+        }
+      this->allocator_->free (this->hashtable_);
+      this->hashtable_ = 0;
+    }
+
+  this->allocator_ = 0;
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::find (const EXT_ID &ext_id) const
+{
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    return -1;
+
+  return this->hashtable_[hash_idx]->find (ext_id);
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::find (const EXT_ID &ext_id,
+                                                ACE_Cache_Object *&int_id) const
+{
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    return -1;
+
+  return this->hashtable_[hash_idx]->find (ext_id, int_id);
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::bind (const EXT_ID &ext_id,
+                                                ACE_Cache_Object *const &int_id)
+{
+  int result;
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    {
+      ACE_Guard<ACE_SYNCH_MUTEX> g (this->lock_);
+
+      if (this->new_cachebucket (hash_idx) == -1)
+        return -1;
+
+      result = this->hashtable_[hash_idx]->bind (ext_id, int_id);
+    }
+  else
+    result = this->hashtable_[hash_idx]->bind (ext_id, int_id);
+
+  return result;
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::trybind (const EXT_ID &ext_id,
+                                                   ACE_Cache_Object *&int_id)
+{
+  int result;
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    {
+      ACE_Guard<ACE_SYNCH_MUTEX> g (this->lock_);
+
+      if (this->new_cachebucket (hash_idx) == -1)
+        return -1;
+
+      result = this->hashtable_[hash_idx]->trybind (ext_id, int_id);
+    }
+  else
+    result = this->hashtable_[hash_idx]->trybind (ext_id, int_id);
+
+  return result;
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::rebind (const EXT_ID &ext_id,
+                                                  ACE_Cache_Object *const &int_id,
+                                                  EXT_ID &old_ext_id,
+                                                  ACE_Cache_Object *&old_int_id)
+{
+  int result;
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    {
+      ACE_Guard<ACE_SYNCH_MUTEX> g (this->lock_);
+
+      if (this->new_cachebucket (hash_idx) == -1)
+        return -1;
+
+      result = this->hashtable_[hash_idx]->rebind (ext_id, int_id,
+                                                   old_ext_id, old_int_id);
+    }
+  else
+    result = this->hashtable_[hash_idx]->rebind (ext_id, int_id,
+                                                 old_ext_id, old_int_id);
+
+  return result;
+}
+
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::unbind (const EXT_ID &ext_id)
+{
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    return -1;
+
+  return this->hashtable_[hash_idx]->unbind (ext_id);
+}
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::unbind (const EXT_ID &ext_id,
+                                                  ACE_Cache_Object *&int_id)
+{
+  unsigned long hash_idx = this->hash (ext_id);
+
+  if (this->hashtable_[hash_idx] == 0)
+    return -1;
+
+  return this->hashtable_[hash_idx]->unbind (ext_id, int_id);
+}
+
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC> size_t
+ACE_Cache_Hash<EXT_ID,HASH_FUNC,EQ_FUNC>::size (void) const
+{
+  return this->size_;
+}
+
+
+
+
+#endif /* UTL_CACHEHASH_T_CPP */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Hash_T.h b/apps/JAWS/PROTOTYPE/JAWS/Cache_Hash_T.h
new file mode 100644
index 00000000000..1d8a0a2c4ae
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Hash_T.h
@@ -0,0 +1,61 @@
+/* -*- c++ -*- */
+// $Id$
+
+#ifndef ACE_CACHE_HASH_T_H
+#define ACE_CACHE_HASH_T_H
+
+#include "ace/OS.h"
+#include "JAWS/Cache_Object.h"
+
+// Forward declaration
+template <class EXT_ID, class INT_ID, class EQ_FUNC>
+class ACE_Hash_Bucket_Manager;
+
+template <class EXT_ID, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_Hash
+{
+public:
+
+  typedef ACE_Hash_Bucket_Manager<EXT_ID, ACE_Cache_Object *, EQ_FUNC>
+          CACHE_BUCKET_MANAGER;
+
+  ACE_Cache_Hash (ACE_Allocator *alloc = 0, size_t size = 521);
+  // 521 == smallest number > 512 that is prime.  Why is a prime
+  // number important?  I am trying to maximize scattering when using
+  // mod on the hashed value.  This might be bogus though.
+
+  virtual ~ACE_Cache_Hash (void);
+
+  int find (const EXT_ID &ext_id) const;
+  int find (const EXT_ID &ext_id, ACE_Cache_Object *&int_id) const;
+  int bind (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id);
+  int trybind (const EXT_ID &ext_id, ACE_Cache_Object *&int_id);
+  int rebind (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id,
+	      EXT_ID &old_ext_id, ACE_Cache_Object *&old_int_id);
+
+  int unbind (const EXT_ID &ext_id);
+  int unbind (const EXT_ID &ext_id, ACE_Cache_Object *&int_id);
+
+  size_t size (void) const;
+
+protected:
+
+  virtual unsigned long hash (const EXT_ID &ext_id) const;
+  int isprime (unsigned long number) const;
+  int new_cachebucket (size_t idx);
+
+private:
+
+  ACE_Allocator *allocator_;
+  size_t size_;
+
+  ACE_SYNCH_MUTEX lock_;
+  CACHE_BUCKET_MANAGER **hashtable_;
+
+};
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "JAWS/Cache_Hash_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#endif /* ACE_CACHE_HASH_T_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Heap_T.cpp b/apps/JAWS/PROTOTYPE/JAWS/Cache_Heap_T.cpp
new file mode 100644
index 00000000000..7b26f02d36a
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Heap_T.cpp
@@ -0,0 +1,282 @@
+// $Id$
+
+#ifndef ACE_CACHE_HEAP_T_CPP
+#define ACE_CACHE_HEAP_T_CPP
+
+#include "JAWS/Cache_Heap_T.h"
+#include "JAWS/Cache_Manager_T.h"
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::ACE_Cache_Heap (ACE_Allocator *alloc,
+                                                       size_t maxsize)
+  : allocator_ (alloc),
+    maxsize_ (maxsize),
+    size_ (0)
+{
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+
+  size_t memsize
+    = this->maxsize_ * sizeof (Cache_Heap_Item *);
+
+  this->heap_ = (Cache_Heap_Item **) this->allocator_->malloc (memsize);
+  if (this->heap_)
+    {
+      for (size_t i = 0; i < this->maxsize_; i++)
+        this->heap_[i] = 0;
+    }
+  else
+    {
+      this->maxsize_ = 0;
+      // should indicate something
+    }
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::~ACE_Cache_Heap (void)
+{
+  if (this->heap_ != 0)
+    {
+      for (size_t i = 0; i < this->maxsize_; i++)
+        {
+          if (this->heap_[i])
+            {
+              ACE_DES_FREE (this->heap_[i], this->allocator_->free,
+                            Cache_Heap_Item);
+              this->heap_[i] = 0;
+            }
+        }
+      this->allocator_->free (this->heap_);
+      this->heap_ = 0;
+    }
+
+  this->allocator_ = 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::is_empty (void) const
+{
+  return (this->size_ == 0);
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::is_full (void) const
+{
+  return (this->size_ == this->maxsize_);
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> size_t
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::size (void) const
+{
+  return this->size_;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> size_t
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::maxsize (void) const
+{
+  return this->maxsize_;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::maxsize (Cache_Manager *cm,
+                                                size_t new_maxsize)
+{
+  int result = -1;
+
+  size_t memsize
+    = new_maxsize * sizeof (Cache_Heap_Item *);
+
+  Cache_Heap_Item **new_heap
+    = (Cache_Heap_Item **) this->allocator_->malloc (memsize);
+  if (new_heap)
+    {
+      while (new_maxsize < this->size_)
+        cm->FLUSH_i ();
+
+      for (size_t i = 0; i < new_maxsize; i++)
+        if (i < this->size_)
+          new_heap[i] = this->heap_[i];
+        else
+          new_heap[i] = 0;
+
+      Cache_Heap_Item ** volatile temp = this->heap_;
+      this->heap_ = new_heap;
+      this->maxsize_ = new_maxsize;
+      this->allocator_->free (temp);
+      result = 0;
+    }
+
+  return result;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> void
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::insert_i (Cache_Heap_Item *item)
+{
+  /* ASSERT: this->size_ < this->maxsize_ */
+
+  size_t i;
+
+  for (i = this->size_ + 1; i > 1; i /= 2)
+    {
+      if (item->priority () > this->heap_[i/2 - 1]->priority ())
+        break;
+
+      this->heap_[i-1] = this->heap_[i/2 - 1];
+      this->heap_[i-1]->heap_idx_ = i-1;
+    }
+
+  this->heap_[i-1] = item;
+  this->heap_[i-1]->heap_idx_ = i-1;
+  this->size_++;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::insert (const EXT_ID &ext_id,
+                                               ACE_Cache_Object *const &int_id)
+{
+  if (this->is_full ())
+    return -1;
+
+  Cache_Heap_Item *item;
+  ACE_NEW_MALLOC_RETURN (item,
+                         (Cache_Heap_Item *)
+                         this->allocator_->malloc (sizeof (Cache_Heap_Item)),
+                         Cache_Heap_Item (ext_id, int_id), -1);
+
+  this->insert_i (item);
+
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> void
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::remove_i (void)
+{
+  /* ASSERT: this->size_ > 0 */
+  this->size_--;
+  Cache_Heap_Item *temp = this->heap_[this->size_];
+  this->heap_[this->size_] = 0;
+
+  size_t i = 1;
+  while (2*i <= this->size_)
+    {
+      size_t child = 2*i;
+      if ((child < this->size_)
+          && (this->heap_[2*i]->priority ()
+              < this->heap_[2*i - 1]->priority ()))
+        child = 2*i + 1;
+
+      if (temp->priority () < this->heap_[child-1]->priority ())
+        break;
+
+      this->heap_[i-1] = this->heap_[child-1];
+      this->heap_[i-1]->heap_idx_ = i-1;
+      i = child;
+    }
+
+  if (this->size_ > 0)
+    {
+      this->heap_[i-1] = temp;
+      this->heap_[i-1]->heap_idx_ = i-1;
+    }
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> void
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::remove_i (size_t pos)
+{
+  Cache_Heap_Item *item = this->heap_[pos];
+
+  if (pos > 0)
+    {
+      int i = pos + 1;
+      do
+        {
+          this->heap_[i-1] = this->heap_[i/2 - 1];
+          this->heap_[i-1]->heap_idx_ = i-1;
+          i /= 2;
+        }
+      while (i > 1);
+    }
+
+  this->heap_[0] = item;
+
+  this->remove_i ();
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::remove (EXT_ID &ext_id,
+                                               ACE_Cache_Object *&int_id)
+{
+  if (this->is_empty ())
+    return -1;
+
+  Cache_Heap_Item *item = this->heap_[0];
+  item->int_id_->heap_item (0);
+
+  this->remove_i ();
+
+  ext_id = item->ext_id_;
+  int_id = item->int_id_;
+
+  ACE_DES_FREE (item, this->allocator_->free, Cache_Heap_Item);
+  item = 0;
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::remove (void *item)
+{
+  if (item == 0)
+    return 0;
+
+  Cache_Heap_Item *real_item = (Cache_Heap_Item *) item;
+
+  // Make sure the item is where it thinks it is.
+  if (this->heap_[real_item->heap_idx_] != real_item)
+    return -1;
+
+  real_item->int_id_->heap_item (0);
+  this->remove_i (real_item->heap_idx_);
+
+  ACE_DES_FREE (real_item, this->allocator_->free, Cache_Heap_Item);
+  real_item = 0;
+
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_Heap<EXT_ID,FACT,H_FN,E_FN>::adjust (void *item)
+{
+  if (item == 0)
+    return 0;
+
+  Cache_Heap_Item *real_item = (Cache_Heap_Item *) item;
+
+  // Make sure the item is where it thinks it is.
+  if (this->heap_[real_item->heap_idx_] != real_item)
+    return -1;
+
+  this->remove_i (real_item->heap_idx_);
+  this->insert_i (real_item);
+
+  return 0;
+}
+
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+ACE_Cache_Heap_Item<EXT_ID,FACT,H_FN,E_FN>::
+ACE_Cache_Heap_Item (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id)
+  : ext_id_ (ext_id),
+    int_id_ (int_id),
+    heap_idx_ (0)
+{
+  this->int_id_->heap_item (this);
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> unsigned int
+ACE_Cache_Heap_Item<EXT_ID,FACT,H_FN,E_FN>::priority (void)
+{
+  return this->int_id_->priority ();
+}
+
+
+#endif /* ACE_CACHE_HEAP_T_CPP */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Heap_T.h b/apps/JAWS/PROTOTYPE/JAWS/Cache_Heap_T.h
new file mode 100644
index 00000000000..f900ca29955
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Heap_T.h
@@ -0,0 +1,103 @@
+/* -*- c++ -*- */
+// $Id$
+
+#ifndef ACE_CACHE_HEAP_T_H
+#define ACE_CACHE_HEAP_T_H
+
+#include "ace/Malloc.h"
+#include "JAWS/Cache_Object.h"
+
+// Forward declarations
+template <class EXT_ID, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_Manager;
+
+template <class EXT_ID, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_Heap_Item;
+
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+class ACE_Cache_Heap
+// Roll my own heap here.  Eventually, a heap should be its own
+// standalone data structure.
+{
+public:
+
+  typedef ACE_Cache_Manager<EXT_ID, FACT, H_FN, E_FN> Cache_Manager;
+  typedef ACE_Cache_Heap_Item<EXT_ID, FACT, H_FN, E_FN> Cache_Heap_Item;
+
+  ACE_Cache_Heap (ACE_Allocator *alloc = 0, size_t maxsize = 8192);
+  // maxsize is the total number of objects the in memory cache is
+  // willing to manage
+
+  ~ACE_Cache_Heap (void);
+
+  int is_empty (void) const;
+  int is_full (void) const;
+
+  size_t size (void) const;
+  size_t maxsize (void) const;
+
+  int maxsize (Cache_Manager *cm, size_t new_maxsize);
+  // attempt to grow (or shrink) the heap.  Return 0 on success, -1 on
+  // error.
+
+  int insert (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id);
+  // attempt to insert int_id into heap.
+
+  int remove (EXT_ID &ext_id, ACE_Cache_Object *&int_id);
+  // attempt to remove the top element of heap.
+
+  int remove (void *item);
+  // treat item as a Cache_Heap_Item, and remove it from the heap
+
+  int adjust (void *item);
+  // treat item as a Cache_Heap_Item, and alter its heap position
+
+protected:
+
+  void insert_i (Cache_Heap_Item *item);
+  // insert item into heap.
+
+  void remove_i (size_t pos);
+  // remove the element residing at pos, but do not delete it.
+
+  void remove_i (void);
+  // remove the element residing at the top of heap, but do not delete it.
+
+private:
+
+  ACE_Allocator *allocator_;
+
+  size_t maxsize_;
+  size_t size_;
+
+  Cache_Heap_Item **heap_;
+
+};
+
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+class ACE_Cache_Heap_Item
+{
+
+  friend class ACE_Cache_Heap<EXT_ID, FACT, H_FN, E_FN>;
+
+public:
+
+  ACE_Cache_Heap_Item (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id);
+  unsigned int priority (void);
+
+private:
+
+  EXT_ID ext_id_;
+  ACE_Cache_Object *int_id_;
+
+  size_t heap_idx_;
+
+};
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "JAWS/Cache_Heap_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#endif /* ACE_CACHE_HEAP_T_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_List_T.cpp b/apps/JAWS/PROTOTYPE/JAWS/Cache_List_T.cpp
new file mode 100644
index 00000000000..dd9a54a6ad4
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_List_T.cpp
@@ -0,0 +1,210 @@
+// $Id$
+
+#ifndef ACE_CACHE_LIST_T_CPP
+#define ACE_CACHE_LIST_T_CPP
+
+#include "JAWS/Cache_List_T.h"
+#include "JAWS/Cache_Manager_T.h"
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::ACE_Cache_List (ACE_Allocator *alloc,
+                                                       size_t maxsize)
+  : allocator_ (alloc),
+    maxsize_ (maxsize),
+    size_ (0),
+    head_ (0),
+    tail_ (0)
+{
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::~ACE_Cache_List (void)
+{
+  while (this->head_ != 0)
+    this->remove (this->head_);
+
+  this->allocator_ = 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::is_empty (void) const
+{
+  return (this->size_ == 0);
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::is_full (void) const
+{
+  return (this->size_ == this->maxsize_);
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> size_t
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::size (void) const
+{
+  return this->size_;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> size_t
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::maxsize (void) const
+{
+  return this->maxsize_;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::maxsize (Cache_Manager *,
+                                                size_t new_maxsize)
+{
+  this->maxsize_ = new_maxsize;
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> void
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::insert_i (Cache_List_Item *item)
+{
+  /* ASSERT: this->size_ < this->maxsize_ */
+  item->next_ = 0;
+  item->prev_ = 0;
+
+  if (this->size_++ == 0)
+    this->head_ = this->tail_ = item;
+  else
+    {
+      this->tail_->next_ = item;
+      item->prev_ = this->tail_;
+      this->tail_ = item;
+    }
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::insert (const EXT_ID &ext_id,
+                                               ACE_Cache_Object *const &int_id)
+{
+  if (this->is_full ())
+    return -1;
+
+  Cache_List_Item *item;
+  ACE_NEW_MALLOC_RETURN (item,
+                         (Cache_List_Item *)
+                         this->allocator_->malloc (sizeof (Cache_List_Item)),
+                         Cache_List_Item (ext_id, int_id), -1);
+
+  this->insert_i (item);
+
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> void
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::remove_i (void)
+{
+  /* ASSERT: this->size_ > 0 */
+  this->size_--;
+  this->item_ = this->head_;
+  if (this->head_ == this->tail_)
+    {
+      this->head_ = this->tail_ = 0;
+      return;
+    }
+
+  this->head_ = this->head_->next_;
+  this->head_->prev_ = 0;
+  this->item_->next_ = 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> void
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::remove_i (Cache_List_Item *item)
+{
+  this->size_--;
+  this->item_ = item;
+
+  if (item->next_ == 0 && item->prev_ == 0)
+    {
+      this->head_ = this->tail_ = 0;
+    }
+  else if (item->next_ == 0)
+    {
+      this->tail_ = item->prev_;
+      this->tail_->next_ = 0;
+    }
+  else if (item->prev_ == 0)
+    {
+      this->head_ = item->next_;
+      this->head_->prev_ = 0;
+    }
+  else
+    {
+      item->next_->prev_ = item->prev_;
+      item->prev_->next_ = item->next_;
+    }
+
+  item->next_ = 0;
+  item->prev_ = 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::remove (EXT_ID &ext_id,
+                                               ACE_Cache_Object *&int_id)
+{
+  if (this->is_empty ())
+    return -1;
+
+  this->remove_i ();
+
+  ext_id = this->item_->ext_id_;
+  int_id = this->item_->int_id_;
+  int_id->heap_item (0);
+
+  ACE_DES_FREE (this->item_, this->allocator_->free, Cache_List_Item);
+  this->item_ = 0;
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::remove (void *item)
+{
+  if (item == 0)
+    return 0;
+
+  this->remove_i ((Cache_List_Item *) item);
+  this->item_->int_id_->heap_item (0);
+
+  ACE_DES_FREE (this->item_, this->allocator_->free, Cache_List_Item);
+  this->item_ = 0;
+
+  return 0;
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> int
+ACE_Cache_List<EXT_ID,FACT,H_FN,E_FN>::adjust (void *item)
+{
+  if (item == 0)
+    return 0;
+
+  Cache_List_Item *real_item = (Cache_List_Item *) item;
+
+  this->remove_i (real_item);
+  this->insert_i (real_item);
+  this->item_ = 0;
+
+  return 0;
+}
+
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+ACE_Cache_List_Item<EXT_ID,FACT,H_FN,E_FN>::
+ACE_Cache_List_Item (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id)
+  : ext_id_ (ext_id),
+    int_id_ (int_id)
+{
+  this->int_id_->heap_item (this);
+}
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN> unsigned int
+ACE_Cache_List_Item<EXT_ID,FACT,H_FN,E_FN>::priority (void)
+{
+  return this->int_id_->priority ();
+}
+
+
+#endif /* ACE_CACHE_LIST_T_CPP */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_List_T.h b/apps/JAWS/PROTOTYPE/JAWS/Cache_List_T.h
new file mode 100644
index 00000000000..49680af9987
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_List_T.h
@@ -0,0 +1,111 @@
+/* -*- c++ -*- */
+// $Id$
+
+#ifndef ACE_CACHE_LIST_T_H
+#define ACE_CACHE_LIST_T_H
+
+#include "ace/Malloc.h"
+#include "JAWS/Cache_Object.h"
+
+// Forward declarations
+template <class EXT_ID, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_Manager;
+
+template <class EXT_ID, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_List_Item;
+
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+class ACE_Cache_List
+// Roll my own heap here.  Eventually, a heap should be its own
+// standalone data structure.
+//
+// This version is not a heap, but a doubly linked list.  We are
+// trying to simplify all the heap operations to be O(1).
+{
+public:
+
+  typedef ACE_Cache_Manager<EXT_ID, FACT, H_FN, E_FN> Cache_Manager;
+  typedef ACE_Cache_List_Item<EXT_ID, FACT, H_FN, E_FN> Cache_List_Item;
+
+  ACE_Cache_List (ACE_Allocator *alloc = 0, size_t maxsize = 8192);
+  // maxsize is the total number of objects the in memory cache is
+  // willing to manage
+
+  ~ACE_Cache_List (void);
+
+  int is_empty (void) const;
+  int is_full (void) const;
+
+  size_t size (void) const;
+  size_t maxsize (void) const;
+
+  int maxsize (Cache_Manager *cm, size_t new_maxsize);
+  // attempt to grow (or shrink) the heap.  Return 0 on success, -1 on
+  // error.
+
+  int insert (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id);
+  // attempt to insert int_id into heap.
+
+  int remove (EXT_ID &ext_id, ACE_Cache_Object *&int_id);
+  // attempt to remove the top element of heap.
+
+  int remove (void *item);
+  // treat item as a Cache_List_Item, and remove it from the heap
+
+  int adjust (void *item);
+  // treat item as a Cache_List_Item, and alter its heap position
+
+protected:
+
+  void insert_i (Cache_List_Item *item);
+  // insert item into heap.
+
+  void remove_i (Cache_List_Item *item);
+  // remove the element residing at pos, but do not delete it.
+
+  void remove_i (void);
+  // remove the element residing at the top of heap, but do not delete it.
+
+private:
+
+  ACE_Allocator *allocator_;
+
+  size_t maxsize_;
+  size_t size_;
+
+  Cache_List_Item *item_;
+
+  Cache_List_Item *head_;
+  Cache_List_Item *tail_;
+
+};
+
+
+template <class EXT_ID, class FACT, class H_FN, class E_FN>
+class ACE_Cache_List_Item
+{
+
+  friend class ACE_Cache_List<EXT_ID, FACT, H_FN, E_FN>;
+
+public:
+
+  typedef ACE_Cache_List<EXT_ID, FACT, H_FN, E_FN> Cache_List;
+
+  ACE_Cache_List_Item (const EXT_ID &ext_id, ACE_Cache_Object *const &int_id);
+  unsigned int priority (void);
+
+private:
+
+  EXT_ID ext_id_;
+  ACE_Cache_Object *int_id_;
+
+  ACE_Cache_List_Item *next_;
+  ACE_Cache_List_Item *prev_;
+};
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "JAWS/Cache_List_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#endif /* ACE_CACHE_LIST_T_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager.cpp b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager.cpp
new file mode 100644
index 00000000000..18370f4a862
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager.cpp
@@ -0,0 +1,204 @@
+// $Id$
+
+#include "ace/OS.h"
+#include "ace/ACE.h"
+#include "ace/Synch.h"
+
+#include "JAWS/Cache_Manager.h"
+
+ACE_String_Hash_Functor::ACE_String_Hash_Functor (const char *s)
+  : i_ (0)
+{
+  this->i_ = ACE::hash_pjw (s);
+}
+
+ACE_String_Hash_Functor::operator unsigned long (void) const
+{
+  return this->i_;
+}
+
+ACE_String_Equal_Functor::ACE_String_Equal_Functor (const char *s1,
+                                                    const char *s2)
+  : i_ (0)
+{
+  this->i_ = ACE_OS::strcmp (s1, s2);
+}
+
+ACE_String_Equal_Functor::operator int (void) const
+{
+  return this->i_ == 0;
+}
+
+ACE_Strdup_String::ACE_Strdup_String (void)
+  : c_ (0),
+    s_ (0)
+{
+}
+
+ACE_Strdup_String::ACE_Strdup_String (const char *s)
+  : c_ (0),
+    s_ (0)
+{
+  this->c_ = new int (1);
+  this->s_ = ACE_OS::strdup (s);
+}
+
+ACE_Strdup_String::ACE_Strdup_String (const ACE_Strdup_String &s)
+  : c_ (s.c_),
+    s_ (s.s_)
+{
+  ++*(this->c_);
+}
+
+ACE_Strdup_String::~ACE_Strdup_String (void)
+{
+  if (this->c_ && --*(this->c_) == 0)
+    {
+      if (this->s_)
+        ACE_OS::free (this->s_);
+      delete this->c_;
+    }
+  this->s_ = 0;
+  this->c_ = 0;
+}
+
+ACE_Strdup_String::operator const char * (void) const
+{
+  return this->s_;
+}
+
+void
+ACE_Strdup_String::operator = (const char *s)
+{
+  if (this->c_ && --*(this->c_) == 0)
+    {
+      if (this->s_)
+        ACE_OS::free (this->s_);
+      delete this->c_;
+    }
+  this->c_ = new int (1);
+  this->s_ = ACE_OS::strdup (s);
+}
+
+void
+ACE_Strdup_String::operator = (const ACE_Strdup_String &s)
+{
+  if (this->c_ && --*(this->c_) == 0)
+    {
+      if (this->s_)
+        ACE_OS::free (this->s_);
+      delete this->c_;
+    }
+  this->c_ = s.c_;
+  this->s_ = s.s_;
+  ++*(this->c_);
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+
+template class ACE_Hash_Bucket_Item<ACE_Strdup_String, ACE_Cache_Object *>;
+template class ACE_Hash_Bucket_DLCStack<ACE_Strdup_String, ACE_Cache_Object *>;
+template class ACE_Hash_Bucket_DLCStack_Iterator<ACE_Strdup_String,
+                                                 ACE_Cache_Object *>;
+template class ACE_Hash_Bucket_Manager<ACE_Strdup_String,
+                                       ACE_Cache_Object *,
+                                       ACE_String_Equal_Functor>;
+template class ACE_Cache_Hash<ACE_Strdup_String,
+                              ACE_String_Hash_Functor,
+                              ACE_String_Equal_Functor>;
+template class ACE_Cache_Heap_Item<ACE_Strdup_String,
+                                   ACE_Referenced_Cache_Object_Factory,
+                                   ACE_String_Hash_Functor,
+                                   ACE_String_Equal_Functor>;
+template class ACE_Cache_Heap<ACE_Strdup_String,
+                              ACE_Referenced_Cache_Object_Factory,
+                              ACE_String_Hash_Functor,
+                              ACE_String_Equal_Functor>;
+template class ACE_Cache_List_Item<ACE_Strdup_String,
+                                   ACE_Referenced_Cache_Object_Factory,
+                                   ACE_String_Hash_Functor,
+                                   ACE_String_Equal_Functor>;
+template class ACE_Cache_List<ACE_Strdup_String,
+                              ACE_Referenced_Cache_Object_Factory,
+                              ACE_String_Hash_Functor,
+                              ACE_String_Equal_Functor>;
+template class ACE_Cache_Manager<ACE_Strdup_String,
+                                 ACE_Referenced_Cache_Object_Factory,
+                                 ACE_String_Hash_Functor,
+                                 ACE_String_Equal_Functor>;
+template class ACE_Cache_Heap_Item<ACE_Strdup_String,
+                                   ACE_Counted_Cache_Object_Factory,
+                                   ACE_String_Hash_Functor,
+                                   ACE_String_Equal_Functor>;
+template class ACE_Cache_Heap<ACE_Strdup_String,
+                              ACE_Counted_Cache_Object_Factory,
+                              ACE_String_Hash_Functor,
+                              ACE_String_Equal_Functor>;
+template class ACE_Cache_List_Item<ACE_Strdup_String,
+                                   ACE_Counted_Cache_Object_Factory,
+                                   ACE_String_Hash_Functor,
+                                   ACE_String_Equal_Functor>;
+template class ACE_Cache_List<ACE_Strdup_String,
+                              ACE_Counted_Cache_Object_Factory,
+                              ACE_String_Hash_Functor,
+                              ACE_String_Equal_Functor>;
+template class ACE_Cache_Manager<ACE_Strdup_String,
+                                 ACE_Counted_Cache_Object_Factory,
+                                 ACE_String_Hash_Functor,
+                                 ACE_String_Equal_Functor>;
+template class ACE_Singleton<ACE_Referenced_Cache_Object_Factory,
+                             ACE_SYNCH_MUTEX>;
+template class ACE_Singleton<ACE_Counted_Cache_Object_Factory,
+                             ACE_SYNCH_MUTEX>;
+template class ACE_Singleton<ACE_String_Referenced_Cache_Manager,
+                             ACE_SYNCH_MUTEX>;
+template class ACE_Singleton<ACE_String_Counted_Cache_Manager,
+                             ACE_SYNCH_MUTEX>;
+
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+
+#pragma instantiate ACE_Hash_Bucket_Item<ACE_Strdup_String, ACE_Cache_Object *>
+#pragma instantiate ACE_Hash_Bucket_DLCStack<ACE_Strdup_String, \
+                                             ACE_Cache_Object *>
+#pragma instantiate ACE_Hash_Bucket_DLCStack_Iterator<ACE_Strdup_String, \
+                                                      ACE_Cache_Object *>
+#pragma instantiate ACE_Hash_Bucket_Manager<ACE_Strdup_String, \
+                                            ACE_Cache_Object *, \
+                                            ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Hash<ACE_Strdup_String, \
+                                   ACE_String_Hash_Functor, \
+                                   ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Heap_Item<ACE_Strdup_String, \
+                                        ACE_Referenced_Cache_Object_Factory, \
+                                        ACE_String_Hash_Functor, \
+                                        ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Heap<ACE_Strdup_String, \
+                                   ACE_Referenced_Cache_Object_Factory, \
+                                   ACE_String_Hash_Functor, \
+                                   ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Manager<ACE_Strdup_String, \
+                                      ACE_Referenced_Cache_Object_Factory, \
+                                      ACE_String_Hash_Functor, \
+                                      ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Heap_Item<ACE_Strdup_String, \
+                                        ACE_Counted_Cache_Object_Factory, \
+                                        ACE_String_Hash_Functor, \
+                                        ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Heap<ACE_Strdup_String, \
+                                   ACE_Counted_Cache_Object_Factory, \
+                                   ACE_String_Hash_Functor, \
+                                   ACE_String_Equal_Functor>
+#pragma instantiate ACE_Cache_Manager<ACE_Strdup_String, \
+                                      ACE_Counted_Cache_Object_Factory, \
+                                      ACE_String_Hash_Functor, \
+                                      ACE_String_Equal_Functor>
+#pragma instantiate ACE_Singleton<ACE_Referenced_Cache_Object_Factory, \
+                                  ACE_SYNCH_MUTEX>
+#pragma instantiate ACE_Singleton<ACE_Counted_Cache_Object_Factory, \
+                                  ACE_SYNCH_MUTEX>
+#pragma instantiate ACE_Singleton<ACE_String_Referenced_Cache_Manager, \
+                                  ACE_SYNCH_MUTEX>
+#pragma instantiate ACE_Singleton<ACE_String_Counted_Cache_Manager, \
+                                  ACE_SYNCH_MUTEX>
+
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager.h b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager.h
new file mode 100644
index 00000000000..bc0d332b94d
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager.h
@@ -0,0 +1,66 @@
+/* -*- c++ -*- */
+// $Id$
+
+#ifndef ACE_CACHE_MANAGER_H
+#define ACE_CACHE_MANAGER_H
+
+#include "ace/OS.h"
+#include "ace/ACE.h"
+#include "ace/Synch.h"
+
+#include "JAWS/Cache_Manager_T.h"
+
+class ACE_String_Hash_Functor
+{
+public:
+  ACE_String_Hash_Functor (const char *s);
+  operator unsigned long (void) const;
+
+private:
+  unsigned long i_;
+};
+
+class ACE_String_Equal_Functor
+{
+public:
+  ACE_String_Equal_Functor (const char *s1, const char *s2);
+  operator int (void) const;
+
+private:
+  int i_;
+};
+
+class ACE_Strdup_String
+{
+public:
+
+  ACE_Strdup_String (void);
+  ACE_Strdup_String (const char *s);
+  ACE_Strdup_String (const ACE_Strdup_String &s);
+  ~ACE_Strdup_String (void);
+
+  operator const char * (void) const;
+  void operator = (const char *s);
+  void operator = (const ACE_Strdup_String &s);
+
+private:
+
+  int *c_;
+  char *s_;
+
+};
+
+typedef ACE_Cache_Manager<ACE_Strdup_String,
+                          ACE_Referenced_Cache_Object_Factory,
+                          ACE_String_Hash_Functor,
+                          ACE_String_Equal_Functor>
+        ACE_String_Referenced_Cache_Manager;
+
+typedef ACE_Cache_Manager<ACE_Strdup_String,
+                          ACE_Counted_Cache_Object_Factory,
+                          ACE_String_Hash_Functor,
+                          ACE_String_Equal_Functor>
+        ACE_String_Counted_Cache_Manager;
+
+
+#endif /* ACE_CACHE_MANAGER_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager_T.cpp b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager_T.cpp
new file mode 100644
index 00000000000..47ee7bf278b
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager_T.cpp
@@ -0,0 +1,554 @@
+// $Id$
+
+#ifndef ACE_CACHE_MANAGER_T_CPP
+#define ACE_CACHE_MANAGER_T_CPP
+
+#include "JAWS/Cache_Manager_T.h"
+#include "JAWS/Cache_Hash_T.h"
+#include "JAWS/Cache_Heap_T.h"
+#include "JAWS/Cache_List_T.h"
+
+#include <iostream.h>
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::ACE_Cache_Manager (ACE_Allocator *alloc,
+                     ACE_Cache_Object_Factory *cof,
+                     size_t hashsize,
+                     size_t maxsize,
+                     size_t maxobjsize,
+                     size_t minobjsize,
+                     size_t highwater,
+                     size_t lowwater,
+                     int timetolive,
+                     int counted)
+  : allocator_ (alloc),
+    factory_ (cof),
+    hashsize_ (hashsize),
+    maxsize_ (maxsize),
+    maxobjsize_ (maxobjsize),
+    minobjsize_ (minobjsize),
+    highwater_ (highwater),
+    lowwater_ (lowwater),
+    waterlevel_ (0),
+    timetolive_ (timetolive),
+    counted_ (counted),
+    hash_ (0),
+    heap_ (0)
+{
+  // Some sanity checking needed here --
+  if (this->lowwater_ > this->highwater_)
+    this->lowwater_ = this->highwater_ / 2;
+
+  if (this->maxobjsize_ > (this->highwater_ - this->lowwater_) * 1024)
+    this->maxobjsize_ = (this->highwater_ - this->lowwater_) * (1024/2);
+
+  if (this->minobjsize_ > this->maxobjsize_)
+    this->minobjsize_ = this->maxobjsize_ / 2;
+
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+
+  if (this->factory_ == 0)
+    this->factory_ = Object_Factory::instance ();
+
+  ACE_NEW_MALLOC (this->hash_,
+                  (Cache_Hash *)
+                  this->allocator_->malloc (sizeof (Cache_Hash)),
+                  Cache_Hash (alloc, hashsize));
+
+  if (this->hash_ == 0)
+    {
+      this->hashsize_ = 0;
+      return;
+    }
+
+  ACE_NEW_MALLOC (this->heap_,
+                  (Cache_Heap *)
+                  this->allocator_->malloc (sizeof (Cache_Heap)),
+                  Cache_Heap (alloc, maxsize));
+
+  if (this->heap_ == 0)
+    {
+      this->maxsize_ = 0;
+
+      ACE_DES_FREE (this->hash_, this->allocator_->free, Cache_Hash);
+      this->hash_ = 0;
+      this->hashsize_ = 0;
+    }
+}
+
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::open (ACE_Allocator *alloc,
+        ACE_Cache_Object_Factory *cof,
+        size_t hashsize,
+        size_t maxsize,
+        size_t maxobjsize,
+        size_t minobjsize,
+        size_t highwater,
+        size_t lowwater,
+        int timetolive,
+        int counted)
+{
+  this->close ();
+
+  this->allocator_ = alloc;
+  this->factory_ = cof;
+  this->hashsize_ = hashsize;
+  this->maxsize_ = maxsize;
+  this->maxobjsize_ = maxobjsize;
+  this->minobjsize_ = minobjsize;
+  this->highwater_ = highwater;
+  this->lowwater_ = lowwater;
+  this->waterlevel_ = 0;
+  this->timetolive_ = timetolive;
+  this->counted_ = counted;
+
+  // Some sanity checking needed here --
+  if (this->lowwater_ > this->highwater_)
+    this->lowwater_ = this->highwater_ / 2;
+
+  if (this->maxobjsize_ > (this->highwater_ - this->lowwater_) * 1024)
+    this->maxobjsize_ = (this->highwater_ - this->lowwater_) * (1024/2);
+
+  if (this->minobjsize_ > this->maxobjsize_)
+    this->minobjsize_ = this->maxobjsize_ / 2;
+
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+
+  if (this->factory_ == 0)
+    this->factory_ = Object_Factory::instance ();
+
+  this->hash_ = (Cache_Hash *) this->allocator_->malloc (sizeof (Cache_Hash));
+  if (this->hash_ == 0)
+    {
+      errno = ENOMEM;
+      this->hashsize_ = 0;
+
+      return -1;
+    }
+  new (this->hash_) Cache_Hash (alloc, hashsize);
+
+  this->heap_ = (Cache_Heap *) this->allocator_->malloc (sizeof (Cache_Heap));
+  if (this->heap_ == 0)
+    {
+      errno = ENOMEM;
+      this->maxsize_ = 0;
+
+      ACE_DES_FREE (this->hash_, this->allocator_->free, Cache_Hash);
+      this->hash_ = 0;
+      this->hashsize_ = 0;
+
+      return -1;
+    }
+  new (this->heap_) Cache_Heap (alloc, maxsize);
+
+  return 0;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>::~ACE_Cache_Manager (void)
+{
+  this->close ();
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>::close (void)
+{
+  while (this->waterlevel_ > 0)
+    this->FLUSH_i ();
+
+  if (this->hash_)
+    {
+      ACE_DES_FREE (this->hash_, this->allocator_->free, Cache_Hash);
+      this->hash_ = 0;
+    }
+
+  if (this->heap_)
+    {
+      ACE_DES_FREE (this->heap_, this->allocator_->free, Cache_Heap);
+      this->heap_ = 0;
+    }
+
+  return 0;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::GET_i (const KEY &key, ACE_Cache_Object *&object)
+{
+  int result = this->hash_->find (key, object);
+
+  if (result == 0)
+    this->TAKE (object);
+  else
+    object = 0;
+
+  return result;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::PUT_i (const KEY &key, const void *data, size_t size, ACE_Cache_Object *&obj)
+{
+  int result = 0;
+
+  if (data == 0)
+    {
+      this->FLUSH_i (key);
+      obj = 0;
+      return 0;
+    }
+
+  result = this->MAKE (data, size, obj);
+  if (result == -1)
+    {
+      cerr << "MAKE failed.  Bummer!" << endl;
+      return -1;
+    }
+
+  obj->internal (new KEY (key));
+
+  KEY old_key;
+  ACE_Cache_Object *old_obj;
+
+  result = this->hash_->rebind (key, obj, old_key, old_obj);
+  if (result == -1)
+    {
+      cerr << "*** hash bind error: " << key << endl;
+      obj->release ();
+      this->DROP_i (obj);
+      return -1;
+    }
+  else if (result == 1)
+    {
+      this->heap_->remove (old_obj->heap_item ());
+      this->waterlevel_ -= old_obj->size ();
+      old_obj->release ();
+      this->DROP_i (old_obj);
+    }
+
+  result = this->heap_->insert (key, obj);
+  if (result == -1)
+    {
+      cerr << "*** heap insertion error: " << key << endl;
+      this->hash_->unbind (key);
+      obj->release ();
+      this->DROP_i (obj);
+      return -1;
+    }
+
+#ifdef ENTERA_VERBOSE_TRACE
+  cerr << "*** bound: " << key << endl;
+#endif
+
+  this->waterlevel_ += size;
+
+  // Acquire this one for the putter.
+  this->TAKE (obj);
+
+  return 0;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::FLUSH_i (const KEY &key)
+{
+  ACE_Cache_Object *temp_object;
+
+#ifdef ENTERA_VERBOSE_TRACE
+  cerr << "*** flush key unbinding: " << key << endl;
+#endif
+  int result = this->hash_->unbind (key, temp_object);
+  if (result == 0)
+    {
+      this->waterlevel_ -= temp_object->size ();
+      if (this->heap_->remove (temp_object->heap_item ()) == -1)
+        cerr << "*** flush key heap remove failed: " << endl;
+      temp_object->release ();
+      this->DROP_i (temp_object);
+    }
+  else
+    cerr << "*** flush key hash unbind failed: " << key << endl;
+
+  return result;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::FLUSH_i (void)
+{
+  KEY temp_key;
+  ACE_Cache_Object *temp_object;
+
+  int result = this->heap_->remove (temp_key, temp_object);
+  if (result == 0)
+    {
+#ifdef ENTERA_VERBOSE_TRACE
+      cerr << "*** flush unbinding: " << temp_key << endl;
+#endif
+      result = this->hash_->unbind (temp_key);
+      if (result == -1)
+        cerr << "*** flush hash unbind failed: " << temp_key << endl;
+      result = 0;
+      this->waterlevel_ -= temp_object->size ();
+      temp_object->release ();
+      this->DROP_i (temp_object);
+    }
+  else
+    {
+      cerr << "*** flush heap remove failed" << endl;
+    }
+
+  return result;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::DROP_i (ACE_Cache_Object *&obj)
+{
+  int result = 0;
+
+  if (obj->count () == 0)
+    {
+      KEY *key = (KEY *) obj->internal ();
+      this->factory_->destroy (obj);
+      delete key;
+      obj = 0;
+      result = 1;
+    }
+  else
+    result = this->heap_->adjust (obj->heap_item ());
+
+  return result;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::GET (const KEY &key, ACE_Cache_Object *&object)
+{
+  ACE_Read_Guard<ACE_SYNCH_RW_MUTEX> g (this->lock_);
+
+  return this->GET_i (key, object);
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::PUT (const KEY &key, const void *data, size_t size, ACE_Cache_Object *&obj)
+{
+  ACE_Write_Guard<ACE_SYNCH_RW_MUTEX> g (this->lock_);
+
+  return this->PUT_i (key, data, size, obj);
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::MAKE (const void *data, size_t size, ACE_Cache_Object *&obj)
+{
+  // verify object is within cacheable range
+  if (size/1024 > this->maxobjsize_)
+    {
+#if 0
+      // What we do is cache it anyway, but remove it as soon as the
+      // requester returns it.
+      obj = this->factory_->create (data, size);
+      return 0;
+#else
+      // The above is a little tricky to implement.  Think about it
+      // some more.
+      cerr << "*** " << size << " is too large to cache" << endl;
+      return -1;
+
+#endif /* 0 */
+    }
+
+  if (size/1024 < this->minobjsize_)
+
+    {
+      // Don't bother to cache this.
+      cerr << "*** " << size << " is too small to cache" << endl;
+      return -1;
+    }
+
+  // make sure we have sufficient memory
+  if (this->waterlevel_ + size > this->highwater_ * (1024 * 1024))
+    {
+      do
+        {
+          if (this->FLUSH_i () == -1)
+            {
+              cerr << "*** cache flooded, flush error" << endl;
+              return -1;
+            }
+        }
+      while (this->waterlevel_ > this->lowwater_ * (1024 * 1024));
+    }
+
+  // make sure heap has enough room
+  if (this->heap_->is_full ())
+    {
+      cerr << "*** heap full, flushing" << endl;
+      if (this->FLUSH_i () == -1)
+        {
+          cerr << "*** heap full, flush error" << endl;
+          return -1;
+        }
+    }
+
+  obj = this->factory_->create (data, size);
+  if (this->TAKE (obj) == -1)
+    {
+      cerr << "*** take error" << endl;
+      this->factory_->destroy (obj);
+      obj = 0;
+      return -1;
+    }
+
+  return 0;
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::TAKE (ACE_Cache_Object *const &obj)
+{
+  if (obj == 0)
+    return -1;
+
+  return obj->acquire ();
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::DROP (ACE_Cache_Object *&obj)
+{
+  if (obj == 0)
+    return -1;
+
+#if 0
+  if (obj->size ()/1024 > this->maxobjsize_)
+    {
+      ACE_Write_Guard<ACE_SYNCH_RW_MUTEX> g (this->lock_);
+
+      int result = obj->release ();
+      if (result == 0)
+        {
+          if (obj->count () == 0)
+            {
+              KEY *key = (KEY *) obj->internal ();
+#ifdef ENTERA_VERBOSE_TRACE
+              cerr << "*** drop large unbinding: " << key << endl;
+#endif
+              result = this->hash_->unbind (*key);
+              if (result == 0)
+                {
+                  if (this->heap_->remove (obj->heap_item ()) == -1)
+                    cerr << "*** drop large heap remove failed: " << endl;
+                  this->factory_->destroy (obj);
+                  delete key;
+                  obj = 0;
+                  result = 1;
+                }
+              else
+                cerr << "*** drop large hash unbind failed: " << key << endl;
+            }
+        }
+      return result;
+    }
+#endif /* 0 */
+
+  {
+    ACE_Write_Guard<ACE_SYNCH_RW_MUTEX> g (this->lock_);
+
+    int result = obj->release ();
+
+    if (result == 0)
+      {
+        if (obj->count () == 0)
+          {
+            KEY *key = (KEY *) obj->internal ();
+            this->factory_->destroy (obj);
+            delete key;
+            obj = 0;
+            result = 1;
+          }
+        else
+          {
+            result = this->DROP_i (obj);
+          }
+      }
+
+    return result;
+  }
+}
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC> int
+ACE_Cache_Manager<KEY,FACTORY,HASH_FUNC,EQ_FUNC>
+::FLUSH (void)
+{
+  ACE_Write_Guard<ACE_SYNCH_RW_MUTEX> g (this->lock_);
+
+  return this->FLUSH_i ();
+}
+
+
+template <class KEY, class DATA, class CACHE_MANAGER>
+ACE_Cache_Proxy<KEY, DATA, CACHE_MANAGER>
+::ACE_Cache_Proxy (const KEY &key, Cache_Manager *manager)
+  : object_ (0),
+    manager_ (manager)
+{
+  if (this->manager_ == 0)
+    this->manager_ = Cache_Manager_Singleton::instance ();
+
+  int result = this->manager_->GET (key, this->object_);
+  if (result == -1)
+    this->object_ = 0;
+}
+
+template <class KEY, class DATA, class CACHE_MANAGER>
+ACE_Cache_Proxy<KEY, DATA, CACHE_MANAGER>
+::ACE_Cache_Proxy (const KEY &key, DATA *data, size_t size,
+                   Cache_Manager *manager)
+  : object_ (0),
+    manager_ (manager)
+{
+  if (this->manager_ == 0)
+    this->manager_ = Cache_Manager_Singleton::instance ();
+
+  int result = this->manager_->PUT (key, data, size, this->object_);
+  if (result == -1)
+    this->object_ = 0;
+}
+
+template <class KEY, class DATA, class CACHE_MANAGER>
+ACE_Cache_Proxy<KEY, DATA, CACHE_MANAGER>::~ACE_Cache_Proxy (void)
+{
+  DATA *data = this->data ();
+  this->manager_->DROP (this->object_);
+  if (this->object_ == 0)
+    this->close (data);
+}
+
+template <class KEY, class DATA, class CACHE_MANAGER> DATA *
+ACE_Cache_Proxy<KEY, DATA, CACHE_MANAGER>::data (void) const
+{
+  return this->object_ ? (DATA *) this->object_->data () : 0;
+}
+
+template <class KEY, class DATA, class CACHE_MANAGER>
+ACE_Cache_Proxy<KEY, DATA, CACHE_MANAGER>::operator DATA * (void) const
+{
+  return this->data ();
+}
+
+template <class KEY, class DATA, class CACHE_MANAGER> int
+ACE_Cache_Proxy<KEY, DATA, CACHE_MANAGER>::close (DATA *)
+{
+  return 0;
+}
+
+
+#endif /* ACE_CACHE_MANAGER_T_CPP */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager_T.h b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager_T.h
new file mode 100644
index 00000000000..3d1557f33dc
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Manager_T.h
@@ -0,0 +1,185 @@
+/* -*- c++ -*- */
+// Hey Emacs!  This is a C++ file!
+// $Id$
+
+#ifndef ACE_CACHE_MANAGER_T_H
+#define ACE_CACHE_MANAGER_T_H
+
+#include "ace/Singleton.h"
+#include "ace/Synch.h"
+
+#include "JAWS/Cache_Object.h"
+
+template <class KEY, class HASH_FUNC, class EQ_FUNC> class ACE_Cache_Hash;
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_Heap;
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_List;
+
+template <class KEY, class FACTORY, class HASH_FUNC, class EQ_FUNC>
+class ACE_Cache_Manager
+{
+
+  friend class ACE_Cache_Hash<KEY, HASH_FUNC, EQ_FUNC>;
+  friend class ACE_Cache_Heap<KEY, FACTORY, HASH_FUNC, EQ_FUNC>;
+  friend class ACE_Cache_List<KEY, FACTORY, HASH_FUNC, EQ_FUNC>;
+
+public:
+
+  typedef ACE_Singleton<FACTORY, ACE_SYNCH_MUTEX> Object_Factory;
+  typedef ACE_Cache_Hash<KEY, HASH_FUNC, EQ_FUNC> Cache_Hash;
+  typedef ACE_Cache_List<KEY, FACTORY, HASH_FUNC, EQ_FUNC> Cache_Heap;
+
+  ACE_Cache_Manager (ACE_Allocator *alloc = 0,
+                     ACE_Cache_Object_Factory *cof = 0,
+
+                     size_t hashsize = 2048,   // number of hash buckets
+                     size_t maxsize = 65535,   // max number of in memory
+                                               // objects
+
+                     size_t maxobjsize = 256,  // max cached object size in kB
+                     size_t minobjsize = 0,    // min cached object size in kB
+
+                     size_t highwater = 100,   // max size of cache in MB
+                     size_t lowwater = 50,     // min size of cache when
+                                               // expiring after highwater
+                                               // has been reached
+
+                     int timetolive = -1,      // amt of time the lowest
+                                               // priority item is allowed to
+                                               // remain in the cache
+
+                     int counted = 0           // flag for whether to use
+                                               // counts
+                     );
+
+  int open (ACE_Allocator *alloc = 0,
+            ACE_Cache_Object_Factory *cof = 0,
+
+            size_t hashsize = 1024,   // number of hash buckets
+            size_t maxsize = 4096,    // max number of in memory
+                                      // objects
+
+            size_t maxobjsize = 5120, // max cached object size in kB
+            size_t minobjsize = 0,    // min cached object size in kB
+
+            size_t highwater = 50,    // max size of cache in MB
+            size_t lowwater = 30,     // min size of cache when
+                                      // expiring after highwater
+                                      // has been reached
+
+            int timetolive = -1,      // amount of time the lowest
+                                      // priority item is allowed to
+                                      // remain in the cache
+
+            int counted = 0           // flag for whether to use
+                                      // counts
+            );
+
+  ~ACE_Cache_Manager (void);
+
+  int close (void);
+
+  // Search Methods
+
+  int GET (const KEY &key, ACE_Cache_Object *&cobj);
+  // Retrieve the object associated with key from cache.  Return 0 on
+  // success, -1 on failure.
+
+  int PUT (const KEY &key, const void *data, size_t size,
+           ACE_Cache_Object *&obj);
+  // Inserts or replaces object associated with key into cache.
+  // Return 0 on success, -1 on failure.
+
+  int MAKE (const void *data, size_t size, ACE_Cache_Object *&cobj);
+  // Create a cached object, increment reference count.
+
+  int TAKE (ACE_Cache_Object *const &cobj);
+  // Increment reference count.
+
+  int DROP (ACE_Cache_Object *&cobj);
+  // Decrement reference count on cached object, perhaps delete.
+  // Returns 0 if only decremented, 1 if deleted, -1 if error.
+
+  int FLUSH (void);
+  // Removes lowest priority object from cache.
+
+protected:
+
+  int GET_i (const KEY &key, ACE_Cache_Object *&object);
+  // Retrieve the object associated with key from cache.  Return 0 on
+  // success, -1 on failure.
+
+  int PUT_i (const KEY &key, const void *data, size_t size,
+             ACE_Cache_Object *&object);
+  // Inserts or replaces object associated with key into cache.
+  // Return 0 on success, -1 on failure.
+
+  int FLUSH_i (void);
+  // Removes lowest priority object from cache.
+
+  int FLUSH_i (const KEY &key);
+  // Removes object associated with key from cache.
+
+  int DROP_i (ACE_Cache_Object *&cobj);
+  // Decrement reference count on cached object, perhaps delete.
+
+private:
+
+  ACE_Allocator *allocator_;
+  ACE_Cache_Object_Factory *factory_;
+
+  size_t hashsize_;
+  size_t maxsize_;
+  size_t maxobjsize_;
+  size_t minobjsize_;
+  size_t highwater_;
+  size_t lowwater_;
+  size_t waterlevel_;
+  int timetolive_;
+  int counted_;
+
+  Cache_Hash *hash_;
+  Cache_Heap *heap_;
+
+  ACE_SYNCH_RW_MUTEX lock_;
+
+};
+
+
+template <class KEY, class DATA, class CACHE_MANAGER>
+class ACE_Cache_Proxy
+{
+public:
+  typedef CACHE_MANAGER Cache_Manager;
+  typedef ACE_Singleton<Cache_Manager, ACE_SYNCH_MUTEX>
+          Cache_Manager_Singleton;
+
+  ACE_Cache_Proxy (const KEY &, Cache_Manager * = 0);
+  // Corresponds to a GET
+
+  ACE_Cache_Proxy (const KEY &, DATA *, size_t, Cache_Manager * = 0);
+  // Corresponds to a U/PUT
+
+  virtual ~ACE_Cache_Proxy (void);
+
+  DATA *data (void) const;
+  operator DATA * (void) const;
+
+  virtual int close (DATA *);
+
+private:
+
+  ACE_Cache_Object *object_;
+  Cache_Manager *manager_;
+
+
+};
+
+
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "JAWS/Cache_Manager_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#endif /* ACE_CACHE_MANAGER_T_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Object.cpp b/apps/JAWS/PROTOTYPE/JAWS/Cache_Object.cpp
new file mode 100644
index 00000000000..846a415b60b
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Object.cpp
@@ -0,0 +1,302 @@
+// $Id$
+
+#include "JAWS/Cache_Object.h"
+
+ACE_Cache_Object::ACE_Cache_Object (const void *data, size_t size)
+  : internal_ (0),
+    data_ (data),
+    size_ (size)
+{
+  this->first_access_ = ACE_OS::time ((time_t *)0);
+  this->new_last_access_ = this->last_access_ = this->first_access_;
+}
+
+ACE_Cache_Object::~ACE_Cache_Object ()
+{
+  this->data_ = 0;
+  this->size_ = 0;
+}
+
+void *
+ACE_Cache_Object::internal (void) const
+{
+  return this->internal_;
+}
+
+void
+ACE_Cache_Object::internal (void *item)
+{
+  this->internal_ = item;
+}
+
+const void *
+ACE_Cache_Object::data (void) const
+{
+  return this->data_;
+}
+
+size_t
+ACE_Cache_Object::size (void) const
+{
+  return this->size_;
+}
+
+unsigned int
+ACE_Cache_Object::count (void) const
+{
+  return this->count_i ();
+}
+
+int
+ACE_Cache_Object::acquire (void)
+{
+  this->new_last_access_ = ACE_OS::time ((time_t *)0);
+  return this->acquire_i ();
+}
+
+int
+ACE_Cache_Object::release (void)
+{
+  this->last_access_ = this->new_last_access_;
+  return this->release_i ();
+}
+
+time_t
+ACE_Cache_Object::last_access (void) const
+{
+  return this->last_access_;
+}
+
+time_t
+ACE_Cache_Object::first_access (void) const
+{
+  return this->first_access_;
+}
+
+unsigned int
+ACE_Cache_Object::priority (void) const
+{
+  return this->priority_i ();
+}
+
+void *
+ACE_Cache_Object::heap_item (void) const
+{
+  return this->heap_item_;
+}
+
+void
+ACE_Cache_Object::heap_item (void *item)
+{
+  this->heap_item_ = item;
+}
+
+
+ACE_Referenced_Cache_Object::
+ACE_Referenced_Cache_Object (const void *data, size_t size)
+  : ACE_Cache_Object (data, size),
+    lock_adapter_ (count_)
+{
+}
+
+ACE_Referenced_Cache_Object::~ACE_Referenced_Cache_Object (void)
+{
+}
+
+ACE_Lock &
+ACE_Referenced_Cache_Object::lock (void)
+{
+  return this->lock_adapter_;
+}
+
+unsigned int
+ACE_Referenced_Cache_Object::count_i (void) const
+{
+  ACE_Referenced_Cache_Object *mutable_this
+    = (ACE_Referenced_Cache_Object *) this;
+
+  if (mutable_this->count_.tryacquire_write () == 0)
+    return 0;
+
+  return 1;
+}
+
+int
+ACE_Referenced_Cache_Object::acquire_i (void)
+{
+  return this->count_.acquire_read ();
+}
+
+int
+ACE_Referenced_Cache_Object::release_i (void)
+{
+  return this->count_.release ();
+}
+
+unsigned int
+ACE_Referenced_Cache_Object::priority_i (void) const
+{
+  unsigned int priority = ~(0U);
+  double delta
+    = ACE_OS::difftime (this->last_access (), this->first_access ());
+
+  if (delta >= 0.0 && delta < ~(0U))
+    priority = (unsigned) delta;
+
+  return priority;
+}
+
+
+
+ACE_Counted_Cache_Object::
+ACE_Counted_Cache_Object (const void *data, size_t size)
+  : ACE_Cache_Object (data, size),
+    count_ (0),
+    new_count_ (0),
+    lock_adapter_ (lock_)
+{
+}
+
+ACE_Counted_Cache_Object::~ACE_Counted_Cache_Object (void)
+{
+}
+
+ACE_Lock &
+ACE_Counted_Cache_Object::lock (void)
+{
+  return this->lock_adapter_;
+}
+
+unsigned int
+ACE_Counted_Cache_Object::count_i (void) const
+{
+  ACE_Counted_Cache_Object *mutable_this = (ACE_Counted_Cache_Object *) this;
+
+  {
+    ACE_Guard<ACE_SYNCH_MUTEX> g (mutable_this->lock_);
+
+    return this->count_;
+  }
+}
+
+int
+ACE_Counted_Cache_Object::acquire_i (void)
+{
+  ACE_Guard<ACE_SYNCH_MUTEX> g (this->lock_);
+
+  this->new_count_++;
+  return 0;
+}
+
+int
+ACE_Counted_Cache_Object::release_i (void)
+{
+  ACE_Guard<ACE_SYNCH_MUTEX> g (this->lock_);
+
+  this->new_count_--;
+  this->count_ = this->new_count_;
+  return 0;
+}
+
+unsigned int
+ACE_Counted_Cache_Object::priority_i (void) const
+{
+  return this->count_i ();
+}
+
+ACE_Cache_Object_Factory::ACE_Cache_Object_Factory (ACE_Allocator *alloc)
+  : allocator_ (alloc)
+{
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+}
+
+ACE_Cache_Object_Factory::~ACE_Cache_Object_Factory (void)
+{
+}
+
+int
+ACE_Cache_Object_Factory::open (ACE_Allocator *alloc)
+{
+  this->allocator_ = alloc;
+
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+
+  return 0;
+}
+
+ACE_Referenced_Cache_Object_Factory
+::ACE_Referenced_Cache_Object_Factory (ACE_Allocator *alloc)
+  : ACE_Cache_Object_Factory (alloc)
+{
+}
+
+ACE_Referenced_Cache_Object_Factory
+::~ACE_Referenced_Cache_Object_Factory (void)
+{
+}
+
+ACE_Cache_Object *
+ACE_Referenced_Cache_Object_Factory::create (const void *data, size_t size)
+{
+  ACE_Referenced_Cache_Object *obj;
+
+  size_t obj_size = sizeof (ACE_Referenced_Cache_Object);
+  ACE_NEW_MALLOC_RETURN (obj,
+                         (ACE_Referenced_Cache_Object *)
+                         this->allocator_->malloc (obj_size),
+                         ACE_Referenced_Cache_Object (data, size), 0);
+
+  return obj;
+}
+
+void
+ACE_Referenced_Cache_Object_Factory::destroy (ACE_Cache_Object *obj)
+{
+  ACE_Referenced_Cache_Object *rco = (ACE_Referenced_Cache_Object *) obj;
+  ACE_DES_FREE (rco, this->allocator_->free, ACE_Referenced_Cache_Object);
+}
+
+ACE_Counted_Cache_Object_Factory
+::ACE_Counted_Cache_Object_Factory (ACE_Allocator *alloc)
+  : ACE_Cache_Object_Factory (alloc)
+{
+}
+
+ACE_Counted_Cache_Object_Factory
+::~ACE_Counted_Cache_Object_Factory (void)
+{
+}
+
+ACE_Cache_Object *
+ACE_Counted_Cache_Object_Factory::create (const void *data, size_t size)
+{
+  ACE_Counted_Cache_Object *obj;
+
+  size_t obj_size = sizeof (ACE_Counted_Cache_Object);
+  ACE_NEW_MALLOC_RETURN (obj,
+                         (ACE_Counted_Cache_Object *)
+                         this->allocator_->malloc (obj_size),
+                         ACE_Counted_Cache_Object (data, size), 0);
+
+  return obj;
+}
+
+void
+ACE_Counted_Cache_Object_Factory::destroy (ACE_Cache_Object *obj)
+{
+  ACE_Counted_Cache_Object *cco = (ACE_Counted_Cache_Object *) obj;
+  ACE_DES_FREE (cco, this->allocator_->free, ACE_Counted_Cache_Object);
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+// These are only specialized with ACE_HAS_THREADS.
+template class ACE_Lock_Adapter<ACE_SYNCH_RW_MUTEX>;
+template class ACE_Lock_Adapter<ACE_SYNCH_MUTEX>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+// These are only specialized with ACE_HAS_THREADS.
+#pragma instantiate ACE_Lock_Adapter<ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Lock_Adapter<ACE_SYNCH_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Cache_Object.h b/apps/JAWS/PROTOTYPE/JAWS/Cache_Object.h
new file mode 100644
index 00000000000..86267940c78
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Cache_Object.h
@@ -0,0 +1,149 @@
+/* -*- c++ -*- */
+// $Id$
+
+
+#ifndef ACE_CACHE_OBJECT_H
+#define ACE_CACHE_OBJECT_H
+
+#include "ace/OS.h"
+#include "ace/Synch.h"
+#include "ace/Malloc.h"
+
+// Cache bucket -- use Hash_Bucket to hold cacheable objects.
+
+class ACE_Cache_Object
+{
+public:
+  ACE_Cache_Object (const void *, size_t);
+  virtual ~ACE_Cache_Object (void);
+
+  void *internal (void) const;
+  void internal (void *);
+
+  const void *data (void) const;
+  size_t size (void) const;
+  unsigned int count (void) const;
+
+  int acquire (void);
+  int release (void);
+
+  time_t last_access (void) const;
+  time_t first_access (void) const;
+
+  unsigned int priority (void) const;
+
+  enum { ACE_CO_REFERENCED, ACE_CO_COUNTED };
+
+  void *heap_item (void) const;
+  void heap_item (void *item);
+
+  virtual ACE_Lock & lock (void) = 0;
+
+protected:
+
+  virtual unsigned int count_i (void) const = 0;
+  virtual int acquire_i (void) = 0;
+  virtual int release_i (void) = 0;
+  virtual unsigned int priority_i (void) const = 0;
+
+private:
+
+  void *internal_;
+  const void *data_;
+  size_t size_;
+
+  time_t last_access_;
+  time_t first_access_;
+  time_t new_last_access_;
+
+  void *heap_item_;
+
+};
+
+class ACE_Referenced_Cache_Object : public ACE_Cache_Object
+{
+public:
+  ACE_Referenced_Cache_Object (const void *, size_t);
+  virtual ~ACE_Referenced_Cache_Object (void);
+
+  virtual ACE_Lock & lock (void);
+
+protected:
+
+  virtual unsigned int count_i (void) const;
+  virtual int acquire_i (void);
+  virtual int release_i (void);
+  virtual unsigned int priority_i (void) const;
+
+private:
+
+  /* MUTABLE */ ACE_SYNCH_RW_MUTEX count_;
+  /* MUTABLE */ ACE_Lock_Adapter<ACE_SYNCH_RW_MUTEX> lock_adapter_;
+  
+};
+
+class ACE_Counted_Cache_Object : public ACE_Cache_Object
+{
+public:
+  ACE_Counted_Cache_Object (const void *, size_t);
+  virtual ~ACE_Counted_Cache_Object (void);
+
+  virtual ACE_Lock & lock (void);
+
+protected:
+
+  virtual unsigned int count_i (void) const;
+  virtual int acquire_i (void);
+  virtual int release_i (void);
+  virtual unsigned int priority_i (void) const;
+
+private:
+
+  unsigned int count_;
+  unsigned int new_count_;
+  /* MUTABLE */ ACE_SYNCH_MUTEX lock_;
+  /* MUTABLE */ ACE_Lock_Adapter<ACE_SYNCH_MUTEX> lock_adapter_;
+
+};
+
+class ACE_Cache_Object_Factory
+{
+public:
+
+  ACE_Cache_Object_Factory (ACE_Allocator *alloc = 0);
+  virtual ~ACE_Cache_Object_Factory (void);
+
+  int open (ACE_Allocator *alloc = 0);
+
+  virtual ACE_Cache_Object * create (const void *, size_t) = 0;
+  virtual void destroy (ACE_Cache_Object *) = 0;
+
+protected:
+
+  ACE_Allocator *allocator_;
+
+};
+
+class ACE_Referenced_Cache_Object_Factory : public ACE_Cache_Object_Factory
+{
+public:
+  ACE_Referenced_Cache_Object_Factory (ACE_Allocator *alloc = 0);
+  virtual ~ACE_Referenced_Cache_Object_Factory (void);
+
+  virtual ACE_Cache_Object * create (const void *, size_t);
+  virtual void destroy (ACE_Cache_Object *);
+
+};
+
+class ACE_Counted_Cache_Object_Factory : public ACE_Cache_Object_Factory
+{
+public:
+  ACE_Counted_Cache_Object_Factory (ACE_Allocator *alloc = 0);
+  virtual ~ACE_Counted_Cache_Object_Factory (void);
+
+  virtual ACE_Cache_Object * create (const void *, size_t);
+  virtual void destroy (ACE_Cache_Object *);
+
+};
+
+#endif /* UTL_CACHE_OBJECT_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Hash_Bucket_T.cpp b/apps/JAWS/PROTOTYPE/JAWS/Hash_Bucket_T.cpp
new file mode 100644
index 00000000000..b7c0cb8c93a
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Hash_Bucket_T.cpp
@@ -0,0 +1,462 @@
+// $Id$
+
+#ifndef ACE_HASH_BUCKET_T_CPP
+#define ACE_HASH_BUCKET_T_CPP
+
+#include "JAWS/Hash_Bucket_T.h"
+
+// -----------------
+// Hash_Bucket_Item
+// -----------------
+
+template <class EXT_ID, class INT_ID>
+ACE_Hash_Bucket_Item<EXT_ID, INT_ID>
+::ACE_Hash_Bucket_Item (const EXT_ID &ext_id, const INT_ID &int_id,
+                        ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *next,
+                        ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *prev)
+  : ext_id_ (ext_id),
+    int_id_ (int_id),
+    next_ (next),
+    prev_ (prev)
+{
+}
+
+template <class EXT_ID, class INT_ID>
+ACE_Hash_Bucket_Item<EXT_ID, INT_ID>
+::ACE_Hash_Bucket_Item (ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *next,
+                        ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *prev)
+  : next_ (next),
+    prev_ (prev)
+{
+}
+
+template <class EXT_ID, class INT_ID>
+ACE_Hash_Bucket_Item<EXT_ID, INT_ID>::~ACE_Hash_Bucket_Item (void)
+{
+  this->next_ = 0;
+  this->prev_ = 0;
+}
+
+
+// ---------------------
+// Hash_Bucket_DLCStack
+// ---------------------
+
+template <class EXT_ID, class INT_ID>
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::
+ACE_Hash_Bucket_DLCStack (ACE_Allocator *alloc)
+  : allocator_ (alloc),
+    head_ (0),
+    tail_ (0)
+{
+  if (this->allocator_ == 0)
+    this->allocator_ = ACE_Allocator::instance ();
+}
+
+template <class EXT_ID, class INT_ID>
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::
+~ACE_Hash_Bucket_DLCStack (void)
+{
+  this->reset ();
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::
+is_empty (void) const
+{
+  return this->head_ == 0 && this->tail_ == 0;
+}
+
+template <class EXT_ID, class INT_ID> ACE_HASH_BUCKET_ITEM *
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::
+push (const EXT_ID &ext_id, const INT_ID &int_id)
+{
+  size_t malloc_size = sizeof (ACE_HASH_BUCKET_ITEM);
+  ACE_HASH_BUCKET_ITEM *item;
+  ACE_NEW_MALLOC_RETURN (item,
+                         (ACE_HASH_BUCKET_ITEM *)
+                         this->allocator_->malloc (malloc_size),
+                         ACE_HASH_BUCKET_ITEM (ext_id, int_id), 0);
+
+  if (item != 0)
+    {
+      if (this->is_empty ())
+        {
+          this->head_ = item;
+          this->tail_ = item;
+          item->next_ = this->head_;
+          item->prev_ = this->tail_;
+        }
+      else
+        {
+          item->next_ = this->head_;
+          item->prev_ = this->tail_;
+          this->head_->prev_ = item;
+          this->tail_->next_ = item;
+          this->head_ = item;
+        }
+    }
+
+  return item;
+}
+
+template <class EXT_ID, class INT_ID> ACE_HASH_BUCKET_ITEM *
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::pop (void)
+{
+  ACE_HASH_BUCKET_ITEM *item = 0;
+
+  if (! this->is_empty ())
+    {
+      item = this->head_;
+      if (this->head_ == this->tail_)
+        {
+          this->head_ = this->tail_ = 0;
+        }
+      else
+        {
+          this->head_ = this->head_->next_;
+          this->head_->prev_ = this->tail_;
+          this->tail_->next_ = this->head_;
+        }
+      item->next_ = 0;
+      item->prev_ = 0;
+    }
+
+  return item;
+}
+
+template <class EXT_ID, class INT_ID> void
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::reset (void)
+{
+  ACE_HASH_BUCKET_ITEM *item = 0;
+
+  while ((item = this->pop ()) != 0)
+    this->remove (item);
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>::remove (ACE_HASH_BUCKET_ITEM *item)
+{
+  int result = 0;
+
+  if (item != 0)
+    {
+      if (item->next_ != 0 && item->prev_ != 0)
+        {
+          if (item->next_ != item)
+            {
+              if (this->head_ == item)
+                this->head_ = item->next_;
+              if (this->tail_ == item)
+                this->tail_ = item->prev_;
+              item->next_->prev_ = item->prev_;
+              item->prev_->next_ = item->next_;
+            }
+          else
+            {
+              this->head_ = this->tail_ = 0;
+            }
+          item->next_ = 0;
+          item->prev_ = 0;
+        }
+
+      if (item->next_ == 0 && item->prev_ == 0)
+        {
+          ACE_DES_FREE_TEMPLATE2 (item, this->allocator_->free,
+                                  ACE_Hash_Bucket_Item, EXT_ID, INT_ID);
+        }
+      else
+        result = -1;
+    }
+
+  return result;
+}
+
+
+// ------------------------------
+// Hash_Bucket_DLCStack_Iterator
+// ------------------------------
+
+template <class EXT_ID, class INT_ID>
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::
+ACE_Hash_Bucket_DLCStack_Iterator (const ACE_HASH_BUCKET_DLCSTACK &dlcstack)
+  : dlcstack_ (dlcstack),
+    next_ (0),
+    prev_ (0),
+    done_ (0)
+{
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::first (void)
+{
+  int result = 0;
+
+  if (! this->dlcstack_.is_empty ())
+    {
+      result = 1;
+      this->next_ = this->dlcstack_.head_;
+      this->prev_ = this->dlcstack_.tail_;
+      this->done_ = 0;
+    }
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::last (void)
+{
+  return this->first ();
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::advance (void)
+{
+  int result = 1;
+
+  if (this->next_ != 0)
+    {
+      this->prev_ = this->next_;
+      this->next_ = this->next_->next_;
+      if (this->next_ == this->dlcstack_.head_)
+        {
+          this->done_ = 1;
+          result = 0;
+        }
+    }
+  else
+    result = this->first ();
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::revert (void)
+{
+  int result = 1;
+
+  if (this->prev_ != 0)
+    {
+      this->next_ = this->prev_;
+      this->prev_ = this->prev_->prev_;
+      if (this->prev_ == this->dlcstack_.tail_)
+        {
+          this->done_ = 1;
+          result = 0;
+        }
+    }
+  else
+    result = this->last ();
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::
+next (ACE_HASH_BUCKET_ITEM *&item)
+{
+  if (this->next_ == 0)
+    this->first ();
+
+  item = this->next_;
+  return ! this->done ();
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::
+next (ACE_HASH_BUCKET_ITEM *&item) const
+{
+  item = this->next_;
+  return ! this->done ();
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::
+prev (ACE_HASH_BUCKET_ITEM *&item)
+{
+  if (this->prev_ == 0)
+    this->last ();
+
+  item = this->prev_;
+  return ! this->done ();
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::
+prev (ACE_HASH_BUCKET_ITEM *&item) const
+{
+  item = this->prev_;
+  return ! this->done ();
+}
+
+template <class EXT_ID, class INT_ID> int
+ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>::done (void) const
+{
+  return this->done_;
+}
+
+
+// --------------------
+// Hash_Bucket_Manager
+// --------------------
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC>
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>
+::ACE_Hash_Bucket_Manager (ACE_Allocator *alloc)
+  : dlcstack_ (alloc)
+{
+  if (alloc == 0)
+    this->dlcstack_.allocator_ = ACE_Allocator::instance ();
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::open (ACE_Allocator *alloc)
+{
+  this->dlcstack_.allocator_ = alloc;
+  if (alloc == 0)
+    this->dlcstack_.allocator_ = ACE_Allocator::instance ();
+
+  return 0;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC>
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::~ACE_Hash_Bucket_Manager (void)
+{
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::close (void)
+{
+  this->dlcstack_.reset ();
+  return 0;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> ACE_HASH_BUCKET_ITEM *
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>
+::find_i (const EXT_ID &ext_id) const
+{
+  ACE_HASH_BUCKET_DLCSTACK_ITERATOR iter (this->dlcstack_);
+  ACE_HASH_BUCKET_ITEM *item = 0;
+
+  if (iter.first ())
+    while (!iter.done ())
+      {
+        iter.next (item);
+        if (item && EQ_FUNC (item->ext_id_, ext_id))
+          break;
+        iter.advance ();
+      }
+
+  return (item && EQ_FUNC (item->ext_id_, ext_id)) ? item : 0;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::find (const EXT_ID &ext_id,
+                                                      INT_ID &int_id) const
+{
+  int result = -1;
+  ACE_HASH_BUCKET_ITEM *item = this->find_i (ext_id);
+
+  if (item)
+    {
+      int_id = item->int_id_;
+      result = 0;
+    }
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>
+::find (const EXT_ID &ext_id) const
+{
+  INT_ID dummy_id;
+  return this->find (ext_id, dummy_id);
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::bind (const EXT_ID &ext_id,
+                                                      const INT_ID &int_id)
+{
+  int result = 0;
+
+  if (this->find (ext_id) == 0)
+    {
+      result = 1;
+    }
+  else
+    {
+      if (this->dlcstack_.push (ext_id, int_id) == 0)
+        result = -1;
+    }
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::trybind (const EXT_ID &ext_id,
+                                                         INT_ID &int_id)
+{
+  int result = 0;
+
+  if (this->find (ext_id, int_id) == 0)
+    {
+      result = 1;
+    }
+  else
+    {
+      if (this->dlcstack_.push (ext_id, int_id) == 0)
+        result = -1;
+    }
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::rebind (const EXT_ID &ext_id,
+                                                        const INT_ID &int_id,
+                                                        EXT_ID &old_ext_id,
+                                                        INT_ID &old_int_id)
+{
+  int result = 0;
+  ACE_HASH_BUCKET_ITEM *item = this->find_i (ext_id);
+
+  if (item)
+    {
+      result = 1;
+      old_ext_id = item->ext_id_;
+      old_int_id = item->int_id_;
+      this->dlcstack_.remove (item);
+    }
+
+  if (this->dlcstack_.push (ext_id, int_id) == 0)
+    result = -1;
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::unbind (const EXT_ID &ext_id,
+                                                        INT_ID &int_id)
+{
+  int result = -1;
+  ACE_HASH_BUCKET_ITEM *item = this->find_i (ext_id);
+
+  if (item)
+    {
+      result = 0;
+      int_id = item->int_id_;
+      this->dlcstack_.remove (item);
+    }
+
+  return result;
+}
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC> int
+ACE_Hash_Bucket_Manager<EXT_ID,INT_ID,EQ_FUNC>::unbind (const EXT_ID &ext_id)
+{
+  INT_ID dummy_id;
+  return this->unbind (ext_id, dummy_id);
+}
+
+#endif /* ACE_HASH_BUCKET_T_CPP */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Hash_Bucket_T.h b/apps/JAWS/PROTOTYPE/JAWS/Hash_Bucket_T.h
new file mode 100644
index 00000000000..d12c11db2e4
--- /dev/null
+++ b/apps/JAWS/PROTOTYPE/JAWS/Hash_Bucket_T.h
@@ -0,0 +1,206 @@
+/* -*- c++ -*- */
+// Hey Emacs!  This is a C++ file!
+// $Id$
+
+#ifndef ACE_HASH_BUCKET_T_H
+#define ACE_HASH_BUCKET_T_H
+
+#include "ace/Containers.h"
+
+#define ACE_HASH_BUCKET_ITEM ACE_Hash_Bucket_Item<EXT_ID, INT_ID>
+#define ACE_HASH_BUCKET_DLCSTACK ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID>
+#define ACE_HASH_BUCKET_DLCSTACK_ITERATOR \
+        ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>
+
+
+// Why Hash_Bucket?
+//
+// This is an attempt to simplify the creation of high-performance
+// hash tables with respect to concurrent access by multiple threads.
+// To this end, we attempt to raise the amount of concurrency through
+// the use or readers/writer locks rather than through mutual
+// exclusion.
+
+template <class EXT_ID, class INT_ID>
+class ACE_Hash_Bucket_Item
+{
+public:
+  ACE_Hash_Bucket_Item (const EXT_ID &ext_id, const INT_ID &int_id,
+                        ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *next = 0,
+                        ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *prev = 0);
+  ACE_Hash_Bucket_Item (ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *next = 0,
+                        ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *prev = 0);
+
+  ~ACE_Hash_Bucket_Item (void);
+  // Destructor.
+
+  EXT_ID ext_id_;
+  // Key used to look up an entry.
+
+  INT_ID int_id_;
+  // The contents of the entry itself.
+
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *next_;
+  // Pointer to the next item in the bucket of overflow nodes.
+
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *prev_;
+  // Pointer to the prev item in the bucket of overflow nodes.
+
+};
+
+
+template <class EXT_ID, class INT_ID> class ACE_Hash_Bucket_DLCStack_Iterator;
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC>
+class ACE_Hash_Bucket_Manager;
+
+template <class EXT_ID, class INT_ID>
+class ACE_Hash_Bucket_DLCStack
+// Create a doubly linked circular stack to be managed by the
+// Hash_Bucket_Manager
+{
+  friend ACE_Hash_Bucket_DLCStack_Iterator<EXT_ID, INT_ID>;
+
+public:
+
+  ACE_Hash_Bucket_DLCStack (ACE_Allocator *alloc = 0);
+  ~ACE_Hash_Bucket_DLCStack (void);
+
+  int is_empty (void) const;
+  // Returns 1 if the container is empty, otherwise returns 0.
+
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *push (const EXT_ID &ext_id,
+                                              const INT_ID &int_id);
+  // Adds <new_item> to the head of the list.
+  // Returns the new item that was inserted.
+
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *pop (void);
+  // Removes and returns the first <item> in the list.  Returns
+  // internal node's address on success, 0 if the queue was empty.
+  // This method will *not* free the internal node.
+
+  void reset (void);
+  // Reset the <ACE_Hash_Bucket_DLCStack> to be empty.
+  // Notice that since no one is interested in the items within,
+  // This operation will delete all items.
+
+  int remove (ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *item);
+  // If item is still part of the CStack, it is removed.
+  // In anycase, if there is no error, item is freed.
+  // Returns 0 if ok, -1 on error.
+
+  ACE_Allocator *allocator_;
+
+private:
+
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *head_;
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *tail_;
+
+};
+
+
+template <class EXT_ID, class INT_ID>
+class ACE_Hash_Bucket_DLCStack_Iterator
+{
+public:
+
+  ACE_Hash_Bucket_DLCStack_Iterator (const ACE_HASH_BUCKET_DLCSTACK &dlcstack);
+
+  int first (void);
+  // Moves to first element in the set, clears done flag.  Returns 0
+  // if empty, 1 otherwise.
+
+  int last (void);
+  // Moves to last element in the set, clears done flag.  Returns 0 if
+  // empty, 1 otherwise.
+
+  int advance (void);
+  // Move forward by one element of set.  Returns 0 if empty or we end
+  // up being the first element in the set, 1 otherwise.  If advance
+  // takes us to the first element, done is set to true.
+
+  int revert (void);
+  // Move backward by one element of set.  Returns 0 if empty or we
+  // end up being the last element in the set, 1 otherwise.  If revert
+  // takes us to the last element, done is set to true.
+
+  int next (ACE_HASH_BUCKET_ITEM *&item);
+  int next (ACE_HASH_BUCKET_ITEM *&item) const;
+  // Pass back the next item.  Returns 0 if done is true, 1 otherwise.
+
+  int prev (ACE_HASH_BUCKET_ITEM *&item);
+  int prev (ACE_HASH_BUCKET_ITEM *&item) const;
+  // Pass back the previous item.  Returns 0 if done is true, 1
+  // otherwise.
+
+  int done (void) const;
+  // Returns 1 if done_ flag is set, 0 otherwise.  done_ flag is set
+  // if next takes us to first element or prev takes us to last
+  // element.
+
+private:
+  const ACE_HASH_BUCKET_DLCSTACK &dlcstack_;
+  ACE_HASH_BUCKET_ITEM *next_;
+  ACE_HASH_BUCKET_ITEM *prev_;
+  int done_;
+};
+
+
+template <class EXT_ID, class INT_ID, class EQ_FUNC>
+class ACE_Hash_Bucket_Manager
+{
+public:
+  ACE_Hash_Bucket_Manager (ACE_Allocator *alloc = 0);
+  int open (ACE_Allocator *alloc = 0);
+
+  ~ACE_Hash_Bucket_Manager (void);
+  int close (void);
+
+  int find (const EXT_ID &ext_id) const;
+  int find (const EXT_ID &ext_id, INT_ID &int_id) const;
+  // Locate <ext_id> and pass out parameter via <int_id>.  If found,
+  // return 0, returns -1 if not found.
+
+  int bind (const EXT_ID &ext_id, const INT_ID &int_id);
+  int trybind (const EXT_ID &ext_id, INT_ID &int_id);
+  // Associate <ext_id> with <int_id> if and only if <ext_id> is not
+  // in the map.  If <ext_id> is already in the map then the <int_id>
+  // parameter is assigned the existing value in the map.  Returns 0
+  // if a new entry is bound successfully, returns 1 if an attempt is
+  // made to bind an existing entry, and returns -1 if failures occur.
+
+  int rebind (const EXT_ID &ext_id, const INT_ID &int_id,
+	      EXT_ID &old_ext_id, INT_ID &old_int_id);
+  // Associate <ext_id> with <int_id>.  If <ext_id> is not in the map
+  // then behaves just like <bind>.  Otherwise, store the old values
+  // of <ext_id> and <int_id> into the "out" parameters and rebind the
+  // new parameters.  This is very useful if you need to have an
+  // atomic way of updating <ACE_Hash_Map_Entrys> and you also need full
+  // control over memory allocation.  Returns 0 if a new entry is
+  // bound successfully, returns 1 if an existing entry was rebound,
+  // and returns -1 if failures occur.
+
+  int unbind (const EXT_ID &ext_id);
+  int unbind (const EXT_ID &ext_id, INT_ID &int_id);
+  // Break any association of <ext_id>.  Returns the value of <int_id>
+  // in case the caller needs to deallocate memory.  Return value is 0
+  // if unbind succeeds, -1 otherwise.
+
+protected:
+
+  ACE_Hash_Bucket_Item<EXT_ID, INT_ID> *find_i (const EXT_ID &ext_id) const;
+  // Returns the item associated with ext_id if found in list.
+  // Returns NULL if not found.
+
+private:
+
+  ACE_Hash_Bucket_DLCStack<EXT_ID, INT_ID> dlcstack_;
+
+};
+
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "JAWS/Hash_Bucket_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#endif /* ACE_HASH_BUCKET_T_H */
diff --git a/apps/JAWS/PROTOTYPE/JAWS/IO.cpp b/apps/JAWS/PROTOTYPE/JAWS/IO.cpp
index ebcb23e0e4c..864e6290ce4 100644
--- a/apps/JAWS/PROTOTYPE/JAWS/IO.cpp
+++ b/apps/JAWS/PROTOTYPE/JAWS/IO.cpp
@@ -192,7 +192,7 @@ JAWS_Synch_IO::transmit_file (JAWS_IO_Handler *ioh,
 
   if (result == ACE_Filecache_Handle::ACE_SUCCESS)
     {
-#if defined (ACE_JAWS_BASELINE)
+#if defined (ACE_JAWS_BASELINE) || defined (ACE_WIN32)
       ACE_SOCK_Stream stream;
       stream.set_handle (ioh->handle ());
 
diff --git a/apps/JAWS/PROTOTYPE/JAWS/Makefile b/apps/JAWS/PROTOTYPE/JAWS/Makefile
index 211a853deb1..fd2632e94f0 100644
--- a/apps/JAWS/PROTOTYPE/JAWS/Makefile
+++ b/apps/JAWS/PROTOTYPE/JAWS/Makefile
@@ -14,6 +14,13 @@ LIB = libJAWS.a
 SHLIB = libJAWS.$(SOEXT)
 
 MYFILES  	= \
+        Cache_Hash_T \
+        Cache_Heap_T \
+        Cache_List_T \
+        Cache_Manager \
+        Cache_Manager_T \
+        Cache_Object \
+        Hash_Bucket_T \
         Headers \
         Parse_Headers \
 	Waiter \
@@ -31,7 +38,7 @@ MYFILES  	= \
 LSRC	= $(addsuffix .cpp,$(MYFILES))
 LOBJ	= $(addsuffix .o,$(MYFILES))
 
-CPPFLAGS += -I.. -DJAWS_NTRACE=0 -DACE_NLOGGING -DJAWS_HAS_THREAD_SAFE_ACCEPT
+CPPFLAGS += -I.. -DJAWS_NTRACE=0 -DACE_NLOGGING #-DJAWS_HAS_THREAD_SAFE_ACCEPT
 
 VLDLIBS = $(LDLIBS:%=%$(VAR))
 
@@ -70,11 +77,10 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
 # DO NOT DELETE THIS LINE -- g++dep uses it.
 # DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
 
-.obj/Headers.o .obj/Headers.so .shobj/Headers.o .shobj/Headers.so: Headers.cpp ../JAWS/Headers.h ../JAWS/Export.h \
+.obj/Cache_Hash_T.o .obj/Cache_Hash_T.so .shobj/Cache_Hash_T.o .shobj/Cache_Hash_T.so: Cache_Hash_T.cpp ../JAWS/Cache_Hash_T.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -86,14 +92,70 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
+ ../JAWS/Cache_Object.h $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
  $(ACE_ROOT)/ace/Containers.h \
  $(ACE_ROOT)/ace/Containers.i \
  $(ACE_ROOT)/ace/Containers_T.h \
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ ../JAWS/Cache_Hash_T.cpp ../JAWS/Hash_Bucket_T.h \
+ ../JAWS/Hash_Bucket_T.cpp
+.obj/Cache_Heap_T.o .obj/Cache_Heap_T.so .shobj/Cache_Heap_T.o .shobj/Cache_Heap_T.so: Cache_Heap_T.cpp ../JAWS/Cache_Heap_T.h \
  $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Synch.h \
@@ -117,6 +179,11 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Malloc_T.cpp \
  $(ACE_ROOT)/ace/Memory_Pool.h \
  $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Signal.i \
  $(ACE_ROOT)/ace/Object_Manager.h \
  $(ACE_ROOT)/ace/Object_Manager.i \
@@ -125,12 +192,22 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(ACE_ROOT)/ace/Mem_Map.h \
  $(ACE_ROOT)/ace/Mem_Map.i \
- $(ACE_ROOT)/ace/Memory_Pool.i
-.obj/Parse_Headers.o .obj/Parse_Headers.so .shobj/Parse_Headers.o .shobj/Parse_Headers.so: Parse_Headers.cpp ../JAWS/Parse_Headers.h \
- ../JAWS/Export.h $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ ../JAWS/Cache_Object.h ../JAWS/Cache_Heap_T.cpp \
+ ../JAWS/Cache_Manager_T.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ ../JAWS/Cache_Manager_T.cpp ../JAWS/Cache_Hash_T.h \
+ ../JAWS/Cache_Hash_T.cpp ../JAWS/Hash_Bucket_T.h \
+ ../JAWS/Hash_Bucket_T.cpp ../JAWS/Cache_List_T.h \
+ ../JAWS/Cache_List_T.cpp
+.obj/Cache_List_T.o .obj/Cache_List_T.so .shobj/Cache_List_T.o .shobj/Cache_List_T.so: Cache_List_T.cpp ../JAWS/Cache_List_T.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -139,11 +216,77 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Trace.h \
  $(ACE_ROOT)/ace/Log_Msg.h \
  $(ACE_ROOT)/ace/Log_Record.h \
- $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ ../JAWS/Cache_Object.h ../JAWS/Cache_List_T.cpp \
+ ../JAWS/Cache_Manager_T.h \
  $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ ../JAWS/Cache_Manager_T.cpp ../JAWS/Cache_Hash_T.h \
+ ../JAWS/Cache_Hash_T.cpp ../JAWS/Hash_Bucket_T.h \
+ ../JAWS/Hash_Bucket_T.cpp ../JAWS/Cache_Heap_T.h \
+ ../JAWS/Cache_Heap_T.cpp
+.obj/Cache_Manager.o .obj/Cache_Manager.so .shobj/Cache_Manager.o .shobj/Cache_Manager.so: Cache_Manager.cpp \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -158,6 +301,8 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ ../JAWS/Cache_Manager.h ../JAWS/Cache_Manager_T.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp \
  $(ACE_ROOT)/ace/Object_Manager.h \
@@ -165,9 +310,72 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Managed_Object.h \
  $(ACE_ROOT)/ace/Managed_Object.i \
  $(ACE_ROOT)/ace/Managed_Object.cpp \
- $(ACE_ROOT)/ace/Message_Block.h \
- $(ACE_ROOT)/ace/Malloc.h \
+ ../JAWS/Cache_Object.h $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ ../JAWS/Cache_Manager_T.cpp ../JAWS/Cache_Hash_T.h \
+ ../JAWS/Cache_Hash_T.cpp ../JAWS/Hash_Bucket_T.h \
+ ../JAWS/Hash_Bucket_T.cpp ../JAWS/Cache_Heap_T.h \
+ ../JAWS/Cache_Heap_T.cpp ../JAWS/Cache_List_T.h \
+ ../JAWS/Cache_List_T.cpp
+.obj/Cache_Manager_T.o .obj/Cache_Manager_T.so .shobj/Cache_Manager_T.o .shobj/Cache_Manager_T.so: Cache_Manager_T.cpp ../JAWS/Cache_Manager_T.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ ../JAWS/Cache_Object.h $(ACE_ROOT)/ace/Malloc.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -186,13 +394,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Mem_Map.h \
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i \
- $(ACE_ROOT)/ace/Message_Block.i \
- ../JAWS/Headers.h
-.obj/Waiter.o .obj/Waiter.so .shobj/Waiter.o .shobj/Waiter.so: Waiter.cpp $(ACE_ROOT)/ace/Proactor.h \
+ ../JAWS/Cache_Manager_T.cpp ../JAWS/Cache_Hash_T.h \
+ ../JAWS/Cache_Hash_T.cpp ../JAWS/Hash_Bucket_T.h \
+ ../JAWS/Hash_Bucket_T.cpp ../JAWS/Cache_Heap_T.h \
+ ../JAWS/Cache_Heap_T.cpp ../JAWS/Cache_List_T.h \
+ ../JAWS/Cache_List_T.cpp
+.obj/Cache_Object.o .obj/Cache_Object.so .shobj/Cache_Object.o .shobj/Cache_Object.so: Cache_Object.cpp ../JAWS/Cache_Object.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -204,18 +414,75 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
- $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Task.h \
- $(ACE_ROOT)/ace/Service_Object.h \
- $(ACE_ROOT)/ace/Shared_Object.h \
- $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
  $(ACE_ROOT)/ace/Event_Handler.h \
  $(ACE_ROOT)/ace/Event_Handler.i \
- $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Synch_T.i \
  $(ACE_ROOT)/ace/Thread.h \
  $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i
+.obj/Hash_Bucket_T.o .obj/Hash_Bucket_T.so .shobj/Hash_Bucket_T.o .shobj/Hash_Bucket_T.so: Hash_Bucket_T.cpp ../JAWS/Hash_Bucket_T.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -223,18 +490,71 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
  $(ACE_ROOT)/ace/Synch.i \
  $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
  $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ ../JAWS/Hash_Bucket_T.cpp
+.obj/Headers.o .obj/Headers.so .shobj/Headers.o .shobj/Headers.so: Headers.cpp ../JAWS/Headers.h ../JAWS/Export.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Containers.h \
  $(ACE_ROOT)/ace/Containers.i \
  $(ACE_ROOT)/ace/Containers_T.h \
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -250,74 +570,116 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(ACE_ROOT)/ace/Mem_Map.h \
  $(ACE_ROOT)/ace/Mem_Map.i \
- $(ACE_ROOT)/ace/Memory_Pool.i \
- $(ACE_ROOT)/ace/Thread_Manager.i \
- $(ACE_ROOT)/ace/Task.i \
- $(ACE_ROOT)/ace/Task_T.h \
- $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Memory_Pool.i
+.obj/Parse_Headers.o .obj/Parse_Headers.so .shobj/Parse_Headers.o .shobj/Parse_Headers.so: Parse_Headers.cpp ../JAWS/Parse_Headers.h \
+ ../JAWS/Export.h $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
  $(ACE_ROOT)/ace/Message_Block.i \
- $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
- $(ACE_ROOT)/ace/Message_Queue_T.h \
- $(ACE_ROOT)/ace/Message_Queue_T.i \
- $(ACE_ROOT)/ace/Message_Queue_T.cpp \
- $(ACE_ROOT)/ace/Strategies.h \
- $(ACE_ROOT)/ace/Strategies_T.h \
- $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ ../JAWS/Headers.h
+.obj/Waiter.o .obj/Waiter.so .shobj/Waiter.o .shobj/Waiter.so: Waiter.cpp $(ACE_ROOT)/ace/Proactor.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config.h \
+ $(ACE_ROOT)/ace/config-g++-common.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
  $(ACE_ROOT)/ace/SString.h \
  $(ACE_ROOT)/ace/SString.i \
- $(ACE_ROOT)/ace/Service_Config.i \
- $(ACE_ROOT)/ace/Reactor.h \
- $(ACE_ROOT)/ace/Handle_Set.h \
- $(ACE_ROOT)/ace/Handle_Set.i \
- $(ACE_ROOT)/ace/Timer_Queue.h \
- $(ACE_ROOT)/ace/Timer_Queue_T.h \
- $(ACE_ROOT)/ace/Timer_Queue_T.i \
- $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
- $(ACE_ROOT)/ace/Reactor.i \
- $(ACE_ROOT)/ace/Reactor_Impl.h \
- $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
- $(ACE_ROOT)/ace/Synch_Options.h \
- $(ACE_ROOT)/ace/Synch_Options.i \
- $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
- $(ACE_ROOT)/ace/Strategies_T.i \
- $(ACE_ROOT)/ace/Strategies_T.cpp \
- $(ACE_ROOT)/ace/Service_Repository.h \
- $(ACE_ROOT)/ace/Service_Types.h \
- $(ACE_ROOT)/ace/Service_Types.i \
- $(ACE_ROOT)/ace/Service_Repository.i \
- $(ACE_ROOT)/ace/WFMO_Reactor.h \
- $(ACE_ROOT)/ace/WFMO_Reactor.i \
- $(ACE_ROOT)/ace/Strategies.i \
- $(ACE_ROOT)/ace/Message_Queue.i \
- $(ACE_ROOT)/ace/Task_T.i \
- $(ACE_ROOT)/ace/Task_T.cpp \
- $(ACE_ROOT)/ace/Module.h \
- $(ACE_ROOT)/ace/Module.i \
- $(ACE_ROOT)/ace/Module.cpp \
- $(ACE_ROOT)/ace/Stream_Modules.h \
- $(ACE_ROOT)/ace/Stream_Modules.i \
- $(ACE_ROOT)/ace/Stream_Modules.cpp \
- $(ACE_ROOT)/ace/Asynch_IO.i \
- $(ACE_ROOT)/ace/Timer_List.h \
- $(ACE_ROOT)/ace/Timer_List_T.h \
- $(ACE_ROOT)/ace/Timer_List_T.cpp \
- $(ACE_ROOT)/ace/Timer_Heap.h \
- $(ACE_ROOT)/ace/Timer_Heap_T.h \
- $(ACE_ROOT)/ace/Timer_Heap_T.cpp \
- $(ACE_ROOT)/ace/Timer_Wheel.h \
- $(ACE_ROOT)/ace/Timer_Wheel_T.h \
- $(ACE_ROOT)/ace/Timer_Wheel_T.cpp \
- $(ACE_ROOT)/ace/High_Res_Timer.h \
- $(ACE_ROOT)/ace/High_Res_Timer.i \
- $(ACE_ROOT)/ace/Pipe.h \
- $(ACE_ROOT)/ace/Pipe.i \
- $(ACE_ROOT)/ace/Proactor.i ../JAWS/Waiter.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i ../JAWS/Waiter.h \
  $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp \
- ../JAWS/Assoc_Array.h ../JAWS/Assoc_Array.cpp ../JAWS/Export.h
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ ../JAWS/Assoc_Array.h ../JAWS/Assoc_Array.cpp ../JAWS/Export.h \
+ ../JAWS/IO_Handler.h $(ACE_ROOT)/ace/Asynch_IO.h
 .obj/Reaper.o .obj/Reaper.so .shobj/Reaper.o .shobj/Reaper.so: Reaper.cpp ../JAWS/Reaper.h \
  $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
@@ -325,7 +687,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -336,6 +697,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -369,7 +733,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -389,6 +752,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Message_Queue.h \
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
  $(ACE_ROOT)/ace/Message_Queue_T.h \
  $(ACE_ROOT)/ace/Message_Queue_T.i \
@@ -396,8 +762,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Strategies.h \
  $(ACE_ROOT)/ace/Strategies_T.h \
  $(ACE_ROOT)/ace/Service_Config.h \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -412,7 +776,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Synch_Options.h \
  $(ACE_ROOT)/ace/Synch_Options.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -433,7 +805,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Stream_Modules.cpp \
  ../JAWS/Export.h ../JAWS/Concurrency.h ../JAWS/IO.h \
  $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
@@ -448,8 +819,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SOCK_Stream.i \
  ../JAWS/IO_Acceptor.h \
  $(ACE_ROOT)/ace/Asynch_Acceptor.h \
- $(ACE_ROOT)/ace/Asynch_Acceptor.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.cpp \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/Time_Value.h \
@@ -462,7 +831,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -473,6 +841,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -499,7 +870,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -517,8 +887,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Managed_Object.h \
  $(ACE_ROOT)/ace/Managed_Object.i \
  $(ACE_ROOT)/ace/Managed_Object.cpp \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -534,6 +902,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/Module.h \
  $(ACE_ROOT)/ace/Task_T.h \
@@ -548,7 +919,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Thread_Manager.h \
  $(ACE_ROOT)/ace/Thread_Manager.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -576,7 +955,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -587,18 +965,24 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Task.h \
- $(ACE_ROOT)/ace/Service_Object.h \
- $(ACE_ROOT)/ace/Shared_Object.h \
- $(ACE_ROOT)/ace/Shared_Object.i \
- $(ACE_ROOT)/ace/Event_Handler.h \
- $(ACE_ROOT)/ace/Event_Handler.i \
- $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/Thread_Manager.h \
- $(ACE_ROOT)/ace/Thread.h \
- $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/SOCK_IO.h \
+ $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
+ $(ACE_ROOT)/ace/IPC_SAP.h \
+ $(ACE_ROOT)/ace/IPC_SAP.i \
+ $(ACE_ROOT)/ace/SOCK.i \
+ $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
+ $(ACE_ROOT)/ace/SOCK_Stream.i \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -606,16 +990,33 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
  $(ACE_ROOT)/ace/Synch.i \
  $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
  $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ ../JAWS/Export.h ../JAWS/Pipeline_Tasks.h ../JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
  $(ACE_ROOT)/ace/Containers.h \
  $(ACE_ROOT)/ace/Containers.i \
  $(ACE_ROOT)/ace/Containers_T.h \
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -624,31 +1025,10 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Malloc_T.i \
  $(ACE_ROOT)/ace/Malloc_T.cpp \
  $(ACE_ROOT)/ace/Memory_Pool.h \
- $(ACE_ROOT)/ace/Signal.h \
- $(ACE_ROOT)/ace/Signal.i \
- $(ACE_ROOT)/ace/Object_Manager.h \
- $(ACE_ROOT)/ace/Object_Manager.i \
- $(ACE_ROOT)/ace/Managed_Object.h \
- $(ACE_ROOT)/ace/Managed_Object.i \
- $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(ACE_ROOT)/ace/Mem_Map.h \
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i \
- $(ACE_ROOT)/ace/Thread_Manager.i \
- $(ACE_ROOT)/ace/Task.i \
- $(ACE_ROOT)/ace/Task_T.h \
- $(ACE_ROOT)/ace/Message_Queue.h \
- $(ACE_ROOT)/ace/Message_Block.h \
- $(ACE_ROOT)/ace/Message_Block.i \
- $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
- $(ACE_ROOT)/ace/Message_Queue_T.h \
- $(ACE_ROOT)/ace/Message_Queue_T.i \
- $(ACE_ROOT)/ace/Message_Queue_T.cpp \
- $(ACE_ROOT)/ace/Strategies.h \
- $(ACE_ROOT)/ace/Strategies_T.h \
- $(ACE_ROOT)/ace/Service_Config.h \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Signal.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -660,10 +1040,36 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Reactor.i \
  $(ACE_ROOT)/ace/Reactor_Impl.h \
  $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ $(ACE_ROOT)/ace/Time_Value.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Message_Queue_T.h \
+ $(ACE_ROOT)/ace/Message_Queue_T.i \
+ $(ACE_ROOT)/ace/Message_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
  $(ACE_ROOT)/ace/Synch_Options.h \
  $(ACE_ROOT)/ace/Synch_Options.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -674,33 +1080,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/WFMO_Reactor.i \
  $(ACE_ROOT)/ace/Strategies.i \
  $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
  $(ACE_ROOT)/ace/Task_T.i \
  $(ACE_ROOT)/ace/Task_T.cpp \
- $(ACE_ROOT)/ace/Module.h \
  $(ACE_ROOT)/ace/Module.i \
  $(ACE_ROOT)/ace/Module.cpp \
  $(ACE_ROOT)/ace/Stream_Modules.h \
  $(ACE_ROOT)/ace/Stream_Modules.i \
  $(ACE_ROOT)/ace/Stream_Modules.cpp \
- $(ACE_ROOT)/ace/Asynch_IO.i \
- $(ACE_ROOT)/ace/SOCK_Stream.h \
- $(ACE_ROOT)/ace/SOCK_IO.h \
- $(ACE_ROOT)/ace/SOCK.h \
- $(ACE_ROOT)/ace/Addr.h \
- $(ACE_ROOT)/ace/Addr.i \
- $(ACE_ROOT)/ace/IPC_SAP.h \
- $(ACE_ROOT)/ace/IPC_SAP.i \
- $(ACE_ROOT)/ace/SOCK.i \
- $(ACE_ROOT)/ace/SOCK_IO.i \
- $(ACE_ROOT)/ace/INET_Addr.h \
- $(ACE_ROOT)/ace/INET_Addr.i \
- $(ACE_ROOT)/ace/SOCK_Stream.i \
- $(ACE_ROOT)/ace/Singleton.h \
- $(ACE_ROOT)/ace/Singleton.i \
- $(ACE_ROOT)/ace/Singleton.cpp ../JAWS/Export.h \
- ../JAWS/Pipeline_Tasks.h ../JAWS/Pipeline.h \
- $(ACE_ROOT)/ace/Stream.h \
- $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/Stream.i \
  $(ACE_ROOT)/ace/Stream.cpp \
  ../JAWS/Pipeline_Handler.h ../JAWS/Pipeline_Handler.cpp \
@@ -712,7 +1100,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -723,9 +1110,11 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Synch.h \
@@ -764,14 +1153,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  ../JAWS/Export.h ../JAWS/Pipeline.h \
  $(ACE_ROOT)/ace/Service_Config.h \
  $(ACE_ROOT)/ace/Service_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.i \
  $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -799,7 +1189,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Thread_Manager.h \
  $(ACE_ROOT)/ace/Thread_Manager.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -827,7 +1225,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp ../JAWS/IO.h \
  $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
@@ -844,7 +1241,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -856,8 +1252,10 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
- $(ACE_ROOT)/ace/Log_Record.i \
- ../JAWS/Concurrency.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Log_Record.i ../JAWS/Concurrency.h \
  $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
@@ -892,7 +1290,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -912,6 +1309,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Message_Queue.h \
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
  $(ACE_ROOT)/ace/Message_Queue_T.h \
  $(ACE_ROOT)/ace/Message_Queue_T.i \
@@ -919,8 +1319,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Strategies.h \
  $(ACE_ROOT)/ace/Strategies_T.h \
  $(ACE_ROOT)/ace/Service_Config.h \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -935,7 +1333,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Synch_Options.h \
  $(ACE_ROOT)/ace/Synch_Options.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -953,9 +1359,8 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Module.cpp \
  $(ACE_ROOT)/ace/Stream_Modules.h \
  $(ACE_ROOT)/ace/Stream_Modules.i \
- $(ACE_ROOT)/ace/Stream_Modules.cpp \
- ../JAWS/IO.h $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp ../JAWS/IO.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
@@ -967,11 +1372,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SOCK_IO.i \
  $(ACE_ROOT)/ace/INET_Addr.h \
  $(ACE_ROOT)/ace/INET_Addr.i \
- $(ACE_ROOT)/ace/SOCK_Stream.i \
- ../JAWS/IO_Handler.h ../JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.i ../JAWS/IO_Handler.h \
+ ../JAWS/IO_Acceptor.h \
  $(ACE_ROOT)/ace/Asynch_Acceptor.h \
- $(ACE_ROOT)/ace/Asynch_Acceptor.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.cpp \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/Time_Value.h \
@@ -984,7 +1387,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -995,6 +1397,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -1028,7 +1433,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -1048,6 +1452,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Message_Queue.h \
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
  $(ACE_ROOT)/ace/Message_Queue_T.h \
  $(ACE_ROOT)/ace/Message_Queue_T.i \
@@ -1055,8 +1462,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Strategies.h \
  $(ACE_ROOT)/ace/Strategies_T.h \
  $(ACE_ROOT)/ace/Service_Config.h \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -1071,7 +1476,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Synch_Options.h \
  $(ACE_ROOT)/ace/Synch_Options.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -1092,7 +1505,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Stream_Modules.cpp \
  ../JAWS/Export.h ../JAWS/IO.h \
  $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
@@ -1104,9 +1516,8 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SOCK_IO.i \
  $(ACE_ROOT)/ace/INET_Addr.h \
  $(ACE_ROOT)/ace/INET_Addr.i \
- $(ACE_ROOT)/ace/SOCK_Stream.i \
- ../JAWS/IO_Handler.h ../JAWS/Pipeline.h \
- $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.i ../JAWS/IO_Handler.h \
+ ../JAWS/Pipeline.h $(ACE_ROOT)/ace/Stream.h \
  $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/Stream.i \
  $(ACE_ROOT)/ace/Stream.cpp \
@@ -1119,7 +1530,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -1130,12 +1540,14 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Get_Opt.i ../JAWS/Server.h \
  ../JAWS/Export.h ../JAWS/Data_Block.h \
  $(ACE_ROOT)/ace/Message_Block.h \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Synch.h \
@@ -1174,14 +1586,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  ../JAWS/Pipeline.h \
  $(ACE_ROOT)/ace/Service_Config.h \
  $(ACE_ROOT)/ace/Service_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.i \
  $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -1209,7 +1622,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Thread_Manager.h \
  $(ACE_ROOT)/ace/Thread_Manager.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -1237,7 +1658,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp ../JAWS/IO.h \
  $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
@@ -1249,11 +1669,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SOCK_IO.i \
  $(ACE_ROOT)/ace/INET_Addr.h \
  $(ACE_ROOT)/ace/INET_Addr.i \
- $(ACE_ROOT)/ace/SOCK_Stream.i \
- ../JAWS/IO_Handler.h ../JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.i ../JAWS/IO_Handler.h \
+ ../JAWS/IO_Acceptor.h \
  $(ACE_ROOT)/ace/Asynch_Acceptor.h \
- $(ACE_ROOT)/ace/Asynch_Acceptor.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.cpp \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.i \
@@ -1265,7 +1683,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -1276,9 +1693,11 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Synch.h \
@@ -1317,14 +1736,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  ../JAWS/Export.h ../JAWS/Pipeline.h \
  $(ACE_ROOT)/ace/Service_Config.h \
  $(ACE_ROOT)/ace/Service_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.i \
  $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -1352,7 +1772,15 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Thread_Manager.h \
  $(ACE_ROOT)/ace/Thread_Manager.i \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Strategies_T.i \
  $(ACE_ROOT)/ace/Strategies_T.cpp \
  $(ACE_ROOT)/ace/Service_Repository.h \
@@ -1377,36 +1805,31 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  ../JAWS/Pipeline_Handler.h ../JAWS/Pipeline_Handler.cpp \
  ../JAWS/IO_Acceptor.h \
  $(ACE_ROOT)/ace/Asynch_Acceptor.h \
- $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.cpp \
- $(ACE_ROOT)/ace/INET_Addr.h \
- $(ACE_ROOT)/ace/Addr.h \
- $(ACE_ROOT)/ace/Addr.i \
- $(ACE_ROOT)/ace/INET_Addr.i \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
+ $(ACE_ROOT)/ace/Addr.h \
+ $(ACE_ROOT)/ace/Addr.i \
  $(ACE_ROOT)/ace/IPC_SAP.h \
  $(ACE_ROOT)/ace/IPC_SAP.i \
  $(ACE_ROOT)/ace/SOCK.i \
  $(ACE_ROOT)/ace/SOCK_IO.i \
+ $(ACE_ROOT)/ace/INET_Addr.h \
+ $(ACE_ROOT)/ace/INET_Addr.i \
  $(ACE_ROOT)/ace/SOCK_Stream.i \
  $(ACE_ROOT)/ace/SOCK_Acceptor.i \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.cpp \
  $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp ../JAWS/IO.h \
- ../JAWS/IO_Handler.h
+ $(ACE_ROOT)/ace/Asynch_IO.h ../JAWS/IO_Handler.h
 .obj/IO_Handler.o .obj/IO_Handler.so .shobj/IO_Handler.o .shobj/IO_Handler.so: IO_Handler.cpp \
  $(ACE_ROOT)/ace/Proactor.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -1418,35 +1841,49 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
- $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Task.h \
- $(ACE_ROOT)/ace/Service_Object.h \
- $(ACE_ROOT)/ace/Shared_Object.h \
- $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Filecache.h \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
  $(ACE_ROOT)/ace/Event_Handler.h \
  $(ACE_ROOT)/ace/Event_Handler.i \
- $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/Thread_Manager.h \
- $(ACE_ROOT)/ace/Thread.h \
- $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
  $(ACE_ROOT)/ace/Synch.i \
- $(ACE_ROOT)/ace/Synch_T.h \
  $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(ACE_ROOT)/ace/Signal.h \
  $(ACE_ROOT)/ace/Containers.h \
  $(ACE_ROOT)/ace/Containers.i \
  $(ACE_ROOT)/ace/Containers_T.h \
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
@@ -1455,31 +1892,13 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Malloc_T.i \
  $(ACE_ROOT)/ace/Malloc_T.cpp \
  $(ACE_ROOT)/ace/Memory_Pool.h \
- $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
  $(ACE_ROOT)/ace/Signal.i \
  $(ACE_ROOT)/ace/Object_Manager.h \
  $(ACE_ROOT)/ace/Object_Manager.i \
  $(ACE_ROOT)/ace/Managed_Object.h \
  $(ACE_ROOT)/ace/Managed_Object.i \
  $(ACE_ROOT)/ace/Managed_Object.cpp \
- $(ACE_ROOT)/ace/Mem_Map.h \
- $(ACE_ROOT)/ace/Mem_Map.i \
- $(ACE_ROOT)/ace/Memory_Pool.i \
- $(ACE_ROOT)/ace/Thread_Manager.i \
- $(ACE_ROOT)/ace/Task.i \
- $(ACE_ROOT)/ace/Task_T.h \
- $(ACE_ROOT)/ace/Message_Queue.h \
- $(ACE_ROOT)/ace/Message_Block.h \
- $(ACE_ROOT)/ace/Message_Block.i \
- $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
- $(ACE_ROOT)/ace/Message_Queue_T.h \
- $(ACE_ROOT)/ace/Message_Queue_T.i \
- $(ACE_ROOT)/ace/Message_Queue_T.cpp \
- $(ACE_ROOT)/ace/Strategies.h \
- $(ACE_ROOT)/ace/Strategies_T.h \
- $(ACE_ROOT)/ace/Service_Config.h \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -1490,46 +1909,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
  $(ACE_ROOT)/ace/Reactor.i \
  $(ACE_ROOT)/ace/Reactor_Impl.h \
- $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
- $(ACE_ROOT)/ace/Synch_Options.h \
- $(ACE_ROOT)/ace/Synch_Options.i \
- $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
- $(ACE_ROOT)/ace/Strategies_T.i \
- $(ACE_ROOT)/ace/Strategies_T.cpp \
- $(ACE_ROOT)/ace/Service_Repository.h \
- $(ACE_ROOT)/ace/Service_Types.h \
- $(ACE_ROOT)/ace/Service_Types.i \
- $(ACE_ROOT)/ace/Service_Repository.i \
- $(ACE_ROOT)/ace/WFMO_Reactor.h \
- $(ACE_ROOT)/ace/WFMO_Reactor.i \
- $(ACE_ROOT)/ace/Strategies.i \
- $(ACE_ROOT)/ace/Message_Queue.i \
- $(ACE_ROOT)/ace/Task_T.i \
- $(ACE_ROOT)/ace/Task_T.cpp \
- $(ACE_ROOT)/ace/Module.h \
- $(ACE_ROOT)/ace/Module.i \
- $(ACE_ROOT)/ace/Module.cpp \
- $(ACE_ROOT)/ace/Stream_Modules.h \
- $(ACE_ROOT)/ace/Stream_Modules.i \
- $(ACE_ROOT)/ace/Stream_Modules.cpp \
- $(ACE_ROOT)/ace/Asynch_IO.i \
- $(ACE_ROOT)/ace/Timer_List.h \
- $(ACE_ROOT)/ace/Timer_List_T.h \
- $(ACE_ROOT)/ace/Timer_List_T.cpp \
- $(ACE_ROOT)/ace/Timer_Heap.h \
- $(ACE_ROOT)/ace/Timer_Heap_T.h \
- $(ACE_ROOT)/ace/Timer_Heap_T.cpp \
- $(ACE_ROOT)/ace/Timer_Wheel.h \
- $(ACE_ROOT)/ace/Timer_Wheel_T.h \
- $(ACE_ROOT)/ace/Timer_Wheel_T.cpp \
- $(ACE_ROOT)/ace/High_Res_Timer.h \
- $(ACE_ROOT)/ace/High_Res_Timer.i \
- $(ACE_ROOT)/ace/Pipe.h \
- $(ACE_ROOT)/ace/Pipe.i \
- $(ACE_ROOT)/ace/Proactor.i \
- $(ACE_ROOT)/ace/Filecache.h ../JAWS/JAWS.h \
- ../JAWS/IO.h $(ACE_ROOT)/ace/SOCK_Stream.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h ../JAWS/JAWS.h \
+ ../JAWS/IO.h $(ACE_ROOT)/ace/Asynch_IO.h \
+ $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
  $(ACE_ROOT)/ace/Addr.h \
@@ -1546,15 +1928,50 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Singleton.cpp ../JAWS/Export.h \
  ../JAWS/IO_Handler.h ../JAWS/IO_Acceptor.h \
  $(ACE_ROOT)/ace/Asynch_Acceptor.h \
- $(ACE_ROOT)/ace/Asynch_Acceptor.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.cpp \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.i \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.cpp \
- ../JAWS/Data_Block.h ../JAWS/Pipeline.h \
- $(ACE_ROOT)/ace/Stream.h \
+ ../JAWS/Data_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ ../JAWS/Pipeline.h $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
+ $(ACE_ROOT)/ace/Module.h \
+ $(ACE_ROOT)/ace/Task_T.h \
+ $(ACE_ROOT)/ace/Message_Queue.h \
+ $(ACE_ROOT)/ace/Message_Queue_T.h \
+ $(ACE_ROOT)/ace/Message_Queue_T.i \
+ $(ACE_ROOT)/ace/Message_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Strategies.h \
+ $(ACE_ROOT)/ace/Strategies_T.h \
+ $(ACE_ROOT)/ace/Synch_Options.h \
+ $(ACE_ROOT)/ace/Synch_Options.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(ACE_ROOT)/ace/Strategies_T.i \
+ $(ACE_ROOT)/ace/Strategies_T.cpp \
+ $(ACE_ROOT)/ace/Service_Repository.h \
+ $(ACE_ROOT)/ace/Service_Types.h \
+ $(ACE_ROOT)/ace/Service_Types.i \
+ $(ACE_ROOT)/ace/Service_Repository.i \
+ $(ACE_ROOT)/ace/WFMO_Reactor.h \
+ $(ACE_ROOT)/ace/WFMO_Reactor.i \
+ $(ACE_ROOT)/ace/Strategies.i \
+ $(ACE_ROOT)/ace/Message_Queue.i \
+ $(ACE_ROOT)/ace/Task.h \
+ $(ACE_ROOT)/ace/Task.i \
+ $(ACE_ROOT)/ace/Task_T.i \
+ $(ACE_ROOT)/ace/Task_T.cpp \
+ $(ACE_ROOT)/ace/Module.i \
+ $(ACE_ROOT)/ace/Module.cpp \
+ $(ACE_ROOT)/ace/Stream_Modules.h \
+ $(ACE_ROOT)/ace/Stream_Modules.i \
+ $(ACE_ROOT)/ace/Stream_Modules.cpp \
  $(ACE_ROOT)/ace/Stream.i \
  $(ACE_ROOT)/ace/Stream.cpp \
  ../JAWS/Pipeline_Handler.h ../JAWS/Pipeline_Handler.cpp \
@@ -1565,7 +1982,6 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
  $(ACE_ROOT)/ace/config.h \
- $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/config-g++-common.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
@@ -1576,9 +1992,11 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Log_Record.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Malloc.h \
- $(ACE_ROOT)/ace/Malloc_Base.h \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Synch.h \
@@ -1617,6 +2035,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i \
  $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
  $(ACE_ROOT)/ace/SOCK_Stream.h \
  $(ACE_ROOT)/ace/SOCK_IO.h \
  $(ACE_ROOT)/ace/SOCK.h \
@@ -1631,14 +2052,20 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/SOCK_Stream.i \
  $(ACE_ROOT)/ace/Filecache.h \
  $(ACE_ROOT)/ace/Hash_Map_Manager.h \
- $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
  $(ACE_ROOT)/ace/Service_Config.h \
  $(ACE_ROOT)/ace/Service_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.h \
  $(ACE_ROOT)/ace/Shared_Object.i \
  $(ACE_ROOT)/ace/Service_Object.i \
- $(ACE_ROOT)/ace/SString.h \
- $(ACE_ROOT)/ace/SString.i \
  $(ACE_ROOT)/ace/Service_Config.i \
  $(ACE_ROOT)/ace/Reactor.h \
  $(ACE_ROOT)/ace/Handle_Set.h \
@@ -1649,9 +2076,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
  $(ACE_ROOT)/ace/Reactor.i \
  $(ACE_ROOT)/ace/Reactor_Impl.h \
- $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
- ../JAWS/JAWS.h ../JAWS/Data_Block.h ../JAWS/Export.h \
- ../JAWS/Pipeline.h $(ACE_ROOT)/ace/Stream.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h ../JAWS/JAWS.h \
+ ../JAWS/Data_Block.h ../JAWS/Export.h ../JAWS/Pipeline.h \
+ $(ACE_ROOT)/ace/Stream.h \
  $(ACE_ROOT)/ace/IO_Cntl_Msg.h \
  $(ACE_ROOT)/ace/Time_Value.h \
  $(ACE_ROOT)/ace/Module.h \
@@ -1692,12 +2119,9 @@ include		$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Singleton.i \
  $(ACE_ROOT)/ace/Singleton.cpp ../JAWS/IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.h \
- $(ACE_ROOT)/ace/Asynch_IO.i \
- ../JAWS/IO_Handler.h ../JAWS/IO_Acceptor.h \
+ $(ACE_ROOT)/ace/Asynch_IO.h ../JAWS/IO_Handler.h \
+ ../JAWS/IO_Acceptor.h \
  $(ACE_ROOT)/ace/Asynch_Acceptor.h \
- $(ACE_ROOT)/ace/Asynch_Acceptor.i \
- $(ACE_ROOT)/ace/Asynch_Acceptor.cpp \
  $(ACE_ROOT)/ace/LOCK_SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.h \
  $(ACE_ROOT)/ace/SOCK_Acceptor.i \