\begin{minipage}[t]{8in}
\begin{tabular}{ll}
virtual  & \verb+~+\Container$<$item$>$\index{Container!\verb+~+\Container$<$item$>$}()
\end{tabular}\\
 
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}The virtual destructor in the \Container\ class
			 ensures that the proper
			 subclass destructor will be called when the object
			 referenced or pointed to is deleted.  The new data
			 structure must define its own destructor (or inherit
			 one from a parent \Container).\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & info\index{Container!info}(ContainerNode *cn) const;
\end{tabular}\\
    
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the data value stored in node {\em cn}.\end{minipage}
\end{minipage}
\vspace{0.2in}

\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & size\index{Container!size}() const = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the number of stored elements.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & emptyQ\index{Container!emptyQ}() const = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return TRUE if there are no stored elements.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & fullQ\index{Container!fullQ}() const = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return TRUE if there are no space left for 
			     additional elements.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool  & memberQ\index{Container!memberQ}(const Item\&e) const = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return TRUE if $e$ is stored.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & min\index{Container!min}() const;
\end{tabular}\\
 	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the minimum data value stored ($O(n)$). 
			 Note that this method is virtual and should be
			 redefined in any descendant class which can 
			 implement it more efficiently.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & max\index{Container!max}() const;
\end{tabular}\\
 	
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the maximum data value stored ($O(n)$). 
			 Like {\em min()}, this should be overridden in
			 any descendant class in which a more efficient
			 implementation is possible.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
DataType  & type\index{Container!type}() const = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Return the type of this structure 
				({\em DataType} is
				an enumerated type defined in general.h).\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Item  & get\index{Container!get}() = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove and return the first element in 
			iteration order.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & remove\index{Container!remove}(Item e) = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Find and remove $e$ from the structure. 
			       If this is a linked structure, delete the
			       \ContainerNode\ containing $e$.  Do not 
				delete $e$.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
void  & clear\index{Container!clear}() = 0;
\end{tabular}\\
 
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}Remove all data from the structure, deleting 
			\ContainerNodes\ but not actual elements.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
int  & iterate\index{Container!iterate}(Iterator$<$Item$>$\& it, Item\& e) const = 0;
\end{tabular}\\
 
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in}This method is used by \Iterator\ objects to obtain
			 the successor of $e$.  Good examples of different
			 implementations of this method are found in Array.h
			 and List.h.  This method is declared to be 
			 \verb+public+ in this class to allow access through
			 \Container\ pointers.  However, it should be 
			 declared private in the descendant classes. The
			 only access should be with \Iterator\ objects.\end{minipage}
\end{minipage}
\vspace{0.2in}



\begin{minipage}[t]{8in}
\begin{tabular}{ll}
ostream\&  & display\index{Container!display}(ostream\&os) = 0;
\end{tabular}\\
 
			
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} This
			 will be called when 
			{\em operator$<$$<$(ostream\&,Container$<$Item$>$\&)} 
			 is invoked.\end{minipage}
\end{minipage}
\vspace{0.2in}


\begin{minipage}[t]{8in}
\begin{tabular}{ll}
Bool operator==(const Collection$<$Item$>$\&) const = 0; 
  \\
Bool operator$<$=(const Collection$<$Item$>$\&) const = 0; 
  \\
Bool operator$<$ (const Collection$<$Item$>$\&) const = 0; 
  \\
Bool operator$>$=(const Collection$<$Item$>$\&) const = 0; 
  \\
Bool operator$>$ (const Collection$<$Item$>$\&) const = 0; 
  \\
Bool operator!=(const Collection$<$Item$>$\&) const = 0;
  \\
Bool operator==(const Container$<$Item$>$\&) const = 0; 
  \\
Bool operator$<$=(const Container$<$Item$>$\&) const = 0; 
  \\
Bool operator$<$ (const Container$<$Item$>$\&) const = 0; 
  \\
Bool operator$>$=(const Container$<$Item$>$\&) const = 0; 
  \\
Bool operator$>$ (const Container$<$Item$>$\&) const = 0; 
  \\
Bool operator!=(const Container$<$Item$>$\&) const = 0;
\end{tabular}\\

		
 \parbox[b]{2in} \ \ 
\begin{minipage}[t]{4in} Compare the \Container\ with a \Collection\ or
		  \Container\ argument.  These methods are defined 
		  in Container.cc and are common to all \Container\
		  objects.\end{minipage}
\end{minipage}
\vspace{0.2in}