// Stacks.cpp,v 1.3 2004/01/05 22:57:06 shuston Exp #include "ace/OS_Memory.h" #include "ace/Log_Msg.h" #include "ace/Containers.h" #include "DataElement.h" class StackExample { public: StackExample (): privateStack_(100) {} // Illustrate all the differnet // types of stacks provided by ACE. int run (void); private: // Illustrate the use of a bounded stack. int runBoundedStack (void); // Illustrate the use of an unbounded stack. int runUnboundedStack (void); // Illustrate the use of a compile time fixed stack. int runFixedStack (void); private: ACE_Bounded_Stack<DataElement*> privateStack_; }; int StackExample::run (void) { ACE_TRACE (ACE_TEXT ("StackUser::run")); ACE_ASSERT(!this->runBoundedStack()); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n# of live objects %d\n"), DataElement::numOfActiveObjects())); ACE_ASSERT(!this->runFixedStack()); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n# of live objects %d\n"), DataElement::numOfActiveObjects())); ACE_ASSERT(!this->runUnboundedStack()); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n# of live objects %d\n"), DataElement::numOfActiveObjects())); return 0; } // Listing 1 code/ch05 int StackExample::runBoundedStack (void) { ACE_TRACE (ACE_TEXT ("StackExample::runBoundedStack")); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Using a bounded stack\n"))); ACE_Bounded_Stack<DataElement> bstack1 (100); // The element array is constrained to this scope. { DataElement elem[100]; for (int i = 0; i < 100; i++) { elem[i].setData(i); // Push the element on the stack. bstack1.push (elem[i]); } } ACE_Bounded_Stack<DataElement> bstack2 (100); // Make a copy! bstack2 = bstack1; for (int j = 0; j < 100; j++) { DataElement elem; bstack2.pop (elem); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d:"), elem.getData ())); } return 0; } // Listing 1 // Listing 2 code/ch05 int StackExample::runFixedStack (void) { ACE_TRACE (ACE_TEXT ("StackExample::runFixedStack")); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Using a fixed stack\n"))); ACE_Fixed_Stack<DataElement*, 100> fstack; for (int k = 0; k < 100; k++) { DataElement* elem; ACE_NEW_RETURN(elem, DataElement (k), -1); fstack.push (elem); // Push the element on the stack. } for (int l = 0; l < 100; l++) { DataElement* elem; fstack.pop (elem); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d:"), elem->getData ())); delete elem; } return 0; } int StackExample::runUnboundedStack (void) { ACE_TRACE (ACE_TEXT ("StackExample::runUnboundedStack")); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Using an unbounded stack\n"))); ACE_Unbounded_Stack<DataElement*> ustack; for (int m = 0; m < 100; m++) { DataElement *elem; ACE_NEW_RETURN(elem, DataElement (m), -1); // Push the element on both stacks. ustack.push (elem); privateStack_.push (elem); } // Oddly enough, you can actually iterate through an // unbounded stack! This is because underneath the covers // the unbounded stack is a linked list. // This will cause the elements in the private stack to // also disappear! ACE_Unbounded_Stack_Iterator<DataElement*> iter (ustack); for (iter.first (); !iter.done (); iter.advance ()) { DataElement** elem; iter.next (elem); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d:"), (*elem)->getData ())); delete (*elem); } return 0; } // Listing 2 int ACE_TMAIN (int, ACE_TCHAR *[]) { StackExample se; return se.run (); } #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) template class ACE_Bounded_Stack<DataElement>; template class ACE_Bounded_Stack<DataElement*>; template class ACE_Fixed_Stack<DataElement*, 100>; template class ACE_Node<DataElement*>; template class ACE_Unbounded_Stack<DataElement*>; template class ACE_Unbounded_Stack_Iterator<DataElement*>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) #pragma instantiate ACE_Bounded_Stack<DataElement> #pragma instantiate ACE_Bounded_Stack<DataElement*> #pragma instantiate ACE_Fixed_Stack<DataElement*, 100> #pragma instantiate ACE_Node<DataElement*> #pragma instantiate ACE_Unbounded_Stack<DataElement*> #pragma instantiate ACE_Unbounded_Stack_Iterator<DataElement*> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION*/