Created a new container class ACE_DLList.

1 files changed, 138 insertions, 1 deletions

diff --git a/ace/Containers.h b/ace/Containers.h
index 6cbd4e42f08..dd9255decb2 100644
--- a/ace/Containers.h
+++ b/ace/Containers.h
@@ -216,9 +216,10 @@ public:
   ~ACE_DNode (void);
   // This isn't necessary, but it keeps the compiler happy.
 
-private:
+//private:
 
   // = Initialization methods
+  ACE_DNode (void) {};
   ACE_DNode (const T &i, ACE_DNode<T> *n = 0, ACE_DNode<T> *p = 0);
 
   ACE_DNode<T> *next_;
@@ -677,6 +678,142 @@ protected:
   // Allocation Strategy of the queue.
 };
 
+//
+// I found ACE_Double_Linked_List really difficult to use.  So, I create
+// another layer of abstraction on top of it to make it easier to use.
+// -- jxh
+template <class T> class ACE_DLList;
+template <class T> class ACE_DLList_Iterator;
+
+template <class T>
+class ACE_DLList_Node : public ACE_DNode<T*>
+{
+friend ACE_DLList<T>;
+friend ACE_DLList_Iterator<T>;
+
+public:
+  ACE_DLList_Node (void)
+    : next_ ((ACE_DLList_Node<T> *) ACE_DNode<T*>::next_),
+      prev_ ((ACE_DLList_Node<T> *) ACE_DNode<T*>::prev_)
+    {};
+  ACE_DLList_Node (T *const &i,
+                   ACE_DLList_Node<T> *n = 0,
+                   ACE_DLList_Node<T> *p = 0)
+    : ACE_DNode<T*> (i, (ACE_DNode<T*> *)n, (ACE_DNode<T*> *)p),
+      next_ ((ACE_DLList_Node<T> *) ACE_DNode<T*>::next_),
+      prev_ ((ACE_DLList_Node<T> *) ACE_DNode<T*>::prev_)
+    {};
+
+  ACE_DLList_Node<T> *next_;
+  ACE_DLList_Node<T> *prev_;
+};
+
+template <class T>
+class ACE_DLList
+  : private ACE_Double_Linked_List< ACE_DLList_Node<T> >
+{
+friend ACE_DLList_Node<T>;
+friend ACE_DLList_Iterator<T>;
+
+public:
+
+  typedef ACE_Double_Linked_List< ACE_DLList_Node<T> > DLList;
+  typedef ACE_DLList_Node<T> DLList_NODE;
+  typedef ACE_DLList_Iterator<T> DLList_ITERATOR;
+
+  void operator= (ACE_DLList<T> &l) { *(DLList *)this = l; };
+
+  // = Check boundary conditions.
+
+  int is_empty (void) const
+    { return ACE_Double_Linked_List< ACE_DLList_Node<T> >::is_empty (); };
+
+  int is_full (void) const
+    { return ACE_Double_Linked_List< ACE_DLList_Node<T> >::is_full (); };
+
+  // = Classic queue operations.
+
+  T *insert_tail (T *new_item);
+  T *insert_head (T *new_item);
+  T* delete_head (void);
+  T *delete_tail (void);
+
+  // = Additional utility methods.
+
+  void reset (void)
+    { ACE_Double_Linked_List< ACE_DLList_Node<T> >::reset (); };
+
+  int get (T *&item, size_t index = 0)
+    {
+      DLList_NODE *node;
+      int result
+        = ACE_Double_Linked_List< ACE_DLList_Node<T> >::get (node, index);
+      item = node->item_;
+      return result;
+    };
+
+  size_t size (void) const
+    { return ACE_Double_Linked_List< ACE_DLList_Node<T> >::size (); };
+
+  void dump (void) const
+    { ACE_Double_Linked_List< ACE_DLList_Node<T> >::dump (); };
+
+  ACE_ALLOC_HOOK_DECLARE;
+
+  // = Initialization and termination methods.
+  ACE_DLList (ACE_Allocator *alloc = 0)
+    : ACE_Double_Linked_List< ACE_DLList_Node<T> > (alloc) {};
+
+  ACE_DLList (ACE_DLList<T> &l)
+    : ACE_Double_Linked_List< ACE_DLList_Node<T> > ((DLList &)l) {};
+
+  ~ACE_DLList (void) { while (this->delete_head ()) ; };
+
+private:
+};
+
+template <class T>
+class ACE_DLList_Iterator
+  : private ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> >
+{
+friend ACE_DLList<T>;
+friend ACE_DLList_Node<T>;
+
+public:
+  // = Initialization method.
+  ACE_DLList_Iterator (ACE_DLList<T> &l)
+    : ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> > (l) {};
+
+  // = Iteration methods.
+
+  T *next (void) const
+    {
+      ACE_DLList_Node<T> *temp
+        = ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> >
+        ::next ();
+      return temp ? temp->item_ : 0;
+    };
+
+  int advance (void)
+    { return
+        ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> >::advance (); };
+
+  int first (void)
+    { return
+        ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> >::first (); };
+
+  int done (void) const
+    { return
+        ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> >::done (); };
+
+  void dump (void) const
+    { ACE_Double_Linked_List_Iterator< ACE_DLList_Node<T> >::dump (); };
+
+  ACE_ALLOC_HOOK_DECLARE;
+
+};
+
+
 template <class T>
 class ACE_Unbounded_Set_Iterator
 {