*** empty log message ***

4 files changed, 169 insertions, 65 deletions

diff --git a/ChangeLog-98b b/ChangeLog-98b
index b95aa40b9be..93d7c2c73db 100644
--- a/ChangeLog-98b
+++ b/ChangeLog-98b
@@ -1,3 +1,21 @@
+Wed Jun 10 12:34:25 1998  Irfan Pyarali  <irfan@cs.wustl.edu>
+
+	* ace/Strategies_T: Added two new template classes: ACE_Recyclable
+ 	  and ACE_Hash_Recyclable. ACE_Recyclable adds a recyclable flag
+ 	  to the class it is instantiated with.  ACE_Hash_Recyclable
+ 	  inherits from ACE_Recyclable and forces the class it is
+ 	  instantiated with to have a hash() method.
+
+	  Also, the Hash_Addr was fixed so that it does not have the
+ 	  recyclable flag anymore, since the Hash_Addr can be used even
+ 	  when there is no recycling.
+
+	  Also updated the ACE_Cached_Connect_Strategy to reflect these
+ 	  changes.
+
+	* tests/Conn_Test.cpp: Fixed the template instantiations in lieu
+ 	  of the changes to Hash_Addr.
+
 Wed Jun 10 11:05:39 1998  David L. Levine  <levine@cs.wustl.edu>
 
         * bin/make_release: replaced ACE_wrappers-repository/ with
diff --git a/ace/Strategies_T.cpp b/ace/Strategies_T.cpp
index 89c0f05aabf..3e3804cc852 100644
--- a/ace/Strategies_T.cpp
+++ b/ace/Strategies_T.cpp
@@ -761,33 +761,79 @@ ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::dump (void) const
   ACE_Scheduling_Strategy<SVC_HANDLER>::dump ();
 }
 
-template<class ADDR_T> size_t
-ACE_Hash_Addr<ADDR_T>::hash_i (const ADDR_T &b) const
+template <class T>
+ACE_Recyclable<T>::ACE_Recyclable (void)
+  : t_ (T ()),
+    recyclable_ (0)
 {
-  ACE_UNUSED_ARG (b);
-  return 0;
 }
 
-template<class ADDR_T>
-ACE_Hash_Addr<ADDR_T>::ACE_Hash_Addr (void)
-  : hash_value_ (0),
-    recyclable_ (0)
+template <class T>
+ACE_Recyclable<T>::ACE_Recyclable (const T &t, int recyclable)
+  : t_ (t),
+    recyclable_ (recyclable)
+{
+}
+
+template <class T>
+ACE_Recyclable<T>::~ACE_Recyclable (void)
+{
+}
+
+template <class T> int
+ACE_Recyclable<T>::operator== (const ACE_Recyclable<T> &rhs) const
+{
+  if (!this->recyclable ())
+    return 0;
+  else
+    return this->t_ == rhs.t_;
+}
+
+template <class T> int
+ACE_Recyclable<T>::recyclable (void) const
+{
+  return this->recyclable_;
+}
+
+template <class T> void
+ACE_Recyclable<T>::recyclable (int new_value)
+{
+  this->recyclable_ = new_value;
+}
+
+template <class T>
+ACE_Hash_Recyclable<T>::ACE_Hash_Recyclable (void)
+  : ACE_Recyclable<T> ()
+{
+}
+
+template <class T>
+ACE_Hash_Recyclable<T>::ACE_Hash_Recyclable (const T &t, int recyclable)
+  : ACE_Recyclable<T> (t, recyclable)
+{
+}
+
+template <class T>
+ACE_Hash_Recyclable<T>::~ACE_Hash_Recyclable (void)
+{
+}
+
+template <class T> u_long
+ACE_Hash_Recyclable<T>::hash (void) const
 {
+  return this->t_.hash ();
 }
 
+
 template<class ADDR_T>
-ACE_Hash_Addr<ADDR_T>::ACE_Hash_Addr (const ADDR_T &a)
-  : hash_value_ (0),
-    recyclable_ (0),
-    addr_ (a)
+ACE_Hash_Addr<ADDR_T>::ACE_Hash_Addr (void)
+  : hash_value_ (0)
 {
-  this->hash ();
 }
 
 template<class ADDR_T>
-ACE_Hash_Addr<ADDR_T>::ACE_Hash_Addr (const ADDR_T &a, int recyclable)
+ACE_Hash_Addr<ADDR_T>::ACE_Hash_Addr (const ADDR_T &a)
   : hash_value_ (0),
-    recyclable_ (recyclable),
     addr_ (a)
 {
   this->hash ();
@@ -808,25 +854,17 @@ ACE_Hash_Addr<ADDR_T>::hash (void) const
   return this->hash_value_;
 }
 
-template<class ADDR_T> int
-ACE_Hash_Addr<ADDR_T>::operator== (const ACE_Hash_Addr<ADDR_T> &rhs) const
+template<class ADDR_T> size_t
+ACE_Hash_Addr<ADDR_T>::hash_i (const ADDR_T &b) const
 {
-  if (!this->recyclable ())
-    return 0;
-  else
-    return this->addr_ == rhs.addr_;
+  ACE_UNUSED_ARG (b);
+  return 0;
 }
 
 template<class ADDR_T> int
-ACE_Hash_Addr<ADDR_T>::recyclable (void) const
-{
-  return this->recyclable_;
-}
-
-template<class ADDR_T> void
-ACE_Hash_Addr<ADDR_T>::recyclable (int new_value)
+ACE_Hash_Addr<ADDR_T>::operator== (const ACE_Hash_Addr<ADDR_T> &rhs) const
 {
-  this->recyclable_ = new_value;
+  return this->addr_ == rhs.addr_;
 }
 
 template <class SVC_HANDLER> int
diff --git a/ace/Strategies_T.h b/ace/Strategies_T.h
index f6d09147836..5c5379957ae 100644
--- a/ace/Strategies_T.h
+++ b/ace/Strategies_T.h
@@ -561,6 +561,56 @@ public:
   // This is a no-op.
 };
 
+template <class T>
+class ACE_Recyclable
+{
+public:
+
+  // = Initialization methods.
+  ACE_Recyclable (void);
+  // Default constructor.
+
+  ACE_Recyclable (const T &t, int recyclable = 0);
+  // Constructor.
+
+  ~ACE_Recyclable (void);
+  // Destructor.
+
+  int operator== (const ACE_Recyclable<T> &rhs) const;
+  // Compares two values.
+
+  // = Set/Get the recyclable bit
+  int recyclable (void) const;
+  void recyclable (int new_value);
+
+protected:
+  int recyclable_;
+  // We need to know if the <T> is "in-use".  If it is, we can
+  // operator==() can skip the comparison.
+
+  T t_;
+  // The underlying class.
+};
+
+template <class T>
+class ACE_Hash_Recyclable : public ACE_Recyclable<T>
+{
+public:
+
+  // = Initialization methods.
+  ACE_Hash_Recyclable (void);
+  // Default constructor.
+
+  ACE_Hash_Recyclable (const T &t, int recyclable = 0);
+  // Constructor.
+
+  ~ACE_Hash_Recyclable (void);
+  // Destructor.
+
+  u_long hash (void) const;
+  // Computes and returns hash value.  
+};
+
 template <class ADDR_T>
 class ACE_Hash_Addr
 {
@@ -580,11 +630,8 @@ public:
   ACE_Hash_Addr (const ADDR_T &a);
   // Pre-compute hash value.
 
-  ACE_Hash_Addr (const ADDR_T &a, int recyclable);
-  // Pre-compute hash value.
-
   ~ACE_Hash_Addr (void);
-  // Default destructor.
+  // Destructor.
 
   u_long hash (void) const;
   // Computes and returns hash value.  This "caches" the hash value to
@@ -593,10 +640,6 @@ public:
   int operator== (const ACE_Hash_Addr<ADDR_T> &rhs) const;
   // Compares two hash values.
 
-  // = Set/Get the recyclable bit
-  int recyclable (void) const;
-  void recyclable (int new_value);
-
 private:
   size_t hash_i (const ADDR_T &) const;
   // This is the method that actually performs the non-cached hash
@@ -605,10 +648,6 @@ private:
   u_long hash_value_;
   // Pre-computed hash-value.
 
-  int recyclable_;
-  // We need to know if the <SVC_HANDLER> is "in-use".  If it is, we
-  // can operator==() can skip the comparison.
-
   ADDR_T addr_;
   // The underlying address.
 };
@@ -713,9 +752,10 @@ private:
 
   // = Typedefs for managing the map
   typedef ACE_Hash_Addr<ACE_PEER_CONNECTOR_ADDR> ADDRESS;
-  typedef ACE_Hash_Map_Manager <ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> CONNECTION_MAP;
-  typedef ACE_Hash_Map_Iterator <ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> CONNECTION_MAP_ITERATOR;
-  typedef ACE_Hash_Map_Entry<ADDRESS, SVC_HANDLER *> CONNECTION_MAP_ENTRY;
+  typedef ACE_Hash_Recyclable<ADDRESS> RECYCLABLE_ADDRESS;
+  typedef ACE_Hash_Map_Manager <RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> CONNECTION_MAP;
+  typedef ACE_Hash_Map_Iterator <RECYCLABLE_ADDRESS, SVC_HANDLER *, ACE_Null_Mutex> CONNECTION_MAP_ITERATOR;
+  typedef ACE_Hash_Map_Entry<RECYCLABLE_ADDRESS, SVC_HANDLER *> CONNECTION_MAP_ENTRY;
 
   CONNECTION_MAP connection_cache_;
   // Table that maintains the cache of connected <SVC_HANDLER>s.
diff --git a/tests/Conn_Test.cpp b/tests/Conn_Test.cpp
index 1877a139d44..f729d65fe52 100644
--- a/tests/Conn_Test.cpp
+++ b/tests/Conn_Test.cpp
@@ -192,7 +192,7 @@ typedef ACE_NOOP_Concurrency_Strategy<Svc_Handler>
         NULL_ACTIVATION_STRATEGY;
 typedef ACE_Cached_Connect_Strategy<Svc_Handler,
                                     ACE_SOCK_CONNECTOR,
-                                    ACE_SYNCH_RW_MUTEX>
+                                    ACE_SYNCH_MUTEX>
         CACHED_CONNECT_STRATEGY;
 
 // ****************************************
@@ -634,23 +634,29 @@ main (int argc, ASYS_TCHAR *argv[])
   return 0;
 }
 
+#define HASH_ADDR ACE_Hash_Addr<ACE_INET_Addr>
+#define RECYCLABLE_ADDR ACE_Recyclable<HASH_ADDR>
+#define HASH_RECYCLABLE_ADDR ACE_Hash_Recyclable<HASH_ADDR>
+
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 template class ACE_Cached_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Hash_Addr<ACE_INET_Addr>;
+template class HASH_ADDR;
+template class RECYCLABLE_ADDR;
+template class HASH_RECYCLABLE_ADDR;
 template class ACE_NOOP_Creation_Strategy<Svc_Handler>;
 template class ACE_Concurrency_Strategy<Svc_Handler>;
 template class ACE_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR>;
 template class ACE_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>;
 template class ACE_Creation_Strategy<Svc_Handler>;
-template class ACE_Hash_Map_Entry<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *>;
-template class ACE_Hash_Map_Manager<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator_Base<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Manager<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Hash_Map_Iterator_Base<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Hash_Map_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Entry<HASH_RECYCLABLE_ADDR, Svc_Handler *>;
+template class ACE_Hash_Map_Manager<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Iterator_Base<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Reverse_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
 template class ACE_LOCK_SOCK_Acceptor<ACCEPTOR_LOCKING>;
 template class ACE_Oneshot_Acceptor<Svc_Handler, LOCK_SOCK_ACCEPTOR>;
 template class ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *>;
@@ -672,21 +678,23 @@ template class ACE_Unbounded_Queue<ACE_Thread_Descriptor*>;
 #endif /* defined (__BORLANDC__) */
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #pragma instantiate ACE_Cached_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Hash_Addr<ACE_INET_Addr>
+#pragma instantiate HASH_ADDR;
+#pragma instantiate RECYCLABLE_ADDR;
+#pragma instantiate HASH_RECYCLABLE_ADDR;
 #pragma instantiate ACE_NOOP_Creation_Strategy<Svc_Handler>
 #pragma instantiate ACE_Concurrency_Strategy<Svc_Handler>
 #pragma instantiate ACE_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR>
 #pragma instantiate ACE_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>
 #pragma instantiate ACE_Creation_Strategy<Svc_Handler>
-#pragma instantiate ACE_Hash_Map_Entry<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Base<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Manager<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Base<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ACE_Hash_Addr<ACE_INET_Addr>, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Entry<HASH_RECYCLABLE_ADDR, Svc_Handler *>
+#pragma instantiate ACE_Hash_Map_Manager<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Iterator_Base<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
 #pragma instantiate ACE_LOCK_SOCK_Acceptor<ACCEPTOR_LOCKING>
 #pragma instantiate ACE_Oneshot_Acceptor<Svc_Handler, LOCK_SOCK_ACCEPTOR>
 #pragma instantiate ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *>