\section{DLList  Class Template Reference}
\label{class_DLList}\index{DLList@{DLList}}
{\tt \#include $<$dllist.h$>$}

Inheritance diagram for DLList\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=61pt]{class_DLList_inherit_graph}
\end{center}
\end{figure}
Collaboration diagram for DLList:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=106pt]{class_DLList_coll_graph}
\end{center}
\end{figure}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
{\bf DLList} ()
\item 
{\bf DLList} (const DLList$<$ T $>$ \&dll)
\item 
{\bf $\sim$DLList} ()
\item 
int {\bf Is\-Empty} () const
\item 
{\bf operator int} () const
\item 
void {\bf Clear} ()
\item 
int {\bf Number} () const
\item 
bool {\bf Add\-To\-Front} (const T \&data)
\item 
bool {\bf Add\-To\-Back} (const T \&data)
\item 
bool {\bf Add\-To\-Front} (const DLList$<$ T $>$ \&dll)
\item 
bool {\bf Add\-To\-Back} (const DLList$<$ T $>$ \&dll)
\item 
bool {\bf Add} (const T \&data)
\item 
bool {\bf Add} (const DLList$<$ T $>$ \&dll)
\item 
const DLList$<$T$>$\& {\bf operator+=} (const DLList$<$ T $>$ \&dll)
\item 
T {\bf Remove\-From\-Front} ()
\item 
T {\bf Remove\-From\-Back} ()
\item 
T {\bf Remove} ()
\item 
const T\& {\bf Get} (int i) const
\item 
T\& {\bf Get} (int i)
\item 
const T\& {\bf Peek\-Front} () const
\item 
T\& {\bf Peek\-Front} ()
\item 
const T\& {\bf Peek\-Back} () const
\item 
T\& {\bf Peek\-Back} ()
\item 
T {\bf Remove\-Location} (int i)
\item 
T {\bf Remove} (const T \&data)
\item 
int {\bf operator==} (const DLList$<$ T $>$ \&dll) const
\item 
int {\bf operator!=} (const DLList$<$ T $>$ \&dll) const
\item 
T\& {\bf Find} (const T \&data)
\item 
const T\& {\bf Find} (const T \&data) const
\item 
int {\bf Find\-Location} (const T \&data) const
\item 
int {\bf In} (const T \&data) const
\item 
ostream\& {\bf Print} (ostream \&os) const
\item 
DLList$<$T$>$ {\bf Unique\-Copy} () const
\item 
const DLList$<$T$>$\& {\bf operator=} (const DLList$<$ T $>$ \&dll)
\item 
DLList$<$T$>$::{\bf Iterator} {\bf Get\-Iterator} ()
\item 
DLList$<$T$>$::{\bf Const\-Iterator} {\bf Get\-Const\-Iterator} () const
\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
{\bf DLList\-Rep}$<$T$>$$\ast$ {\bf the\_\-rep}
\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf Iterator}
\item 
class {\bf Const\-Iterator}
\item 
ostream\& {\bf operator} (ostream \&os, const DLList$<$ T $>$ \&dll)
\item 
istream\& {\bf Input\-Binary} (istream \&is, DLList$<$ T $>$ \&dll)
\item 
istream\& {\bf operator$>$=} (istream \&is, DLList$<$ T $>$ \&dll)
\item 
ostream\& {\bf Output\-Binary} (ostream \&os, const DLList$<$ T $>$ \&dll)
\item 
ostream\& {\bf operator} (ostream \&os, const DLList$<$ T $>$ \&dll)
\end{CompactItemize}
\subsubsection*{template$<$class T$>$  class DLList}



\subsection{Constructor \& Destructor Documentation}
\index{DLList@{DLList}!DLList@{DLList}}
\index{DLList@{DLList}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$ T $>$::DLList$<$T$>$ ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a0}




Definition at line 459 of file dllist.inc.\footnotesize\begin{verbatim}00460   { the_rep = new DLListRep<T>(); }
00461 \end{verbatim}\normalsize 
\index{DLList@{DLList}!DLList@{DLList}}
\index{DLList@{DLList}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$ T $>$::DLList$<$T$>$ (const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a1}




Definition at line 463 of file dllist.inc.\footnotesize\begin{verbatim}00464   { 
00465     the_rep = dll.the_rep;
00466     if(the_rep) the_rep->Reference();
00467 \end{verbatim}\normalsize 
\index{DLList@{DLList}!~DLList@{$\sim$DLList}}
\index{~DLList@{$\sim$DLList}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$ T $>$::$\sim$DLList$<$T$>$ ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a2}




Definition at line 470 of file dllist.inc.\footnotesize\begin{verbatim}00471   { 
00472     if(the_rep) 
00473         the_rep->Dereference(); 
00474     the_rep = 0; 
00475 \end{verbatim}\normalsize 


\subsection{Member Function Documentation}
\index{DLList@{DLList}!Add@{Add}}
\index{Add@{Add}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ bool DLList$<$ T $>$::Add (const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a12}




Definition at line 162 of file dllist.inc.\footnotesize\begin{verbatim}00163   { return AddToBack(dll); }
00164 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Add@{Add}}
\index{Add@{Add}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ bool DLList$<$ T $>$::Add (const T \& {\em x})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a11}




Reimplemented in {\bf Queue} {\rm (p.\,\pageref{class_Queue_a0})}.

Definition at line 158 of file dllist.inc.

Referenced by Queue::operator+=(), and Molecule::read\-Fasta().\footnotesize\begin{verbatim}00159   { return AddToBack(data); }
00160 \end{verbatim}\normalsize 
\index{DLList@{DLList}!AddToBack@{AddToBack}}
\index{AddToBack@{AddToBack}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ bool DLList$<$ T $>$::Add\-To\-Back (const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a10}




Definition at line 127 of file dllist.inc.\footnotesize\begin{verbatim}00128 {
00129   if(!dll.the_rep->Head) return false;
00130   if(IsEmpty()) { *this = dll.UniqueCopy(); return false; }
00131   
00132   DLListNode<T> * Hop, * New, * ExtPoint, * Previous;
00133 
00134   Hop      = dll.the_rep->Head;
00135   New      = new DLListNode<T>(Hop->Data);
00136   ExtPoint = New;
00137 
00138   Hop = Hop->Next;
00139   while(Hop)
00140     {
00141       Previous = New;
00142       New = new DLListNode<T>(Hop->Data);
00143       New->Prev = Previous;
00144       Previous->Next = New;
00145       Hop = Hop->Next;
00146     }
00147 \end{verbatim}\normalsize 
\index{DLList@{DLList}!AddToBack@{AddToBack}}
\index{AddToBack@{AddToBack}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ bool DLList$<$ T $>$::Add\-To\-Back (const T \& {\em data})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a8}




Definition at line 68 of file dllist.inc.

Referenced by Queue::Add(), Add(), Molecule::Dyn\-Read(), Input\-Binary(), Segments::QSort\-Reduce(), sd\-Graph::Trav\-Lists(), Unique\-Copy(), Process::add\-Child(), j\-Vector::dynread(), Int\-Vec::dynread(), Constraint\-Manager::get\-Assoc\-Atoms(), Constraint\-Manager::get\-Parents(), main(), and operator+=().\footnotesize\begin{verbatim}00069 {
00070   // Create a new node.
00071   //
00072   DLListNode<T> * New = new DLListNode<T>(data);
00073 
00074   // Make the node the new tail of the list.
00075   //
00076   if(IsEmpty())
00077     {
00078       New->Next = 0;
00079       New->Prev = 0;
00080       the_rep->Head = New;
00081       the_rep->Tail = New;
00082     }
00083   else
00084     {
00085       the_rep->Tail->Next = New;
00086       New->Prev  = the_rep->Tail;
00087       New->Next  = 0;
00088       the_rep->Tail = New;
00089     }
00090 \end{verbatim}\normalsize 
\index{DLList@{DLList}!AddToFront@{AddToFront}}
\index{AddToFront@{AddToFront}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ bool DLList$<$ T $>$::Add\-To\-Front (const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a9}




Definition at line 96 of file dllist.inc.\footnotesize\begin{verbatim}00097 {
00098   if(!dll.the_rep->Head) return false;
00099   if(IsEmpty()) { *this = dll.UniqueCopy(); return false; }
00100   
00101   DLListNode<T> * Hop, * New, * NewHead, * Previous;
00102 
00103   Hop     = dll.the_rep->Head;
00104   New     = new DLListNode<T>(Hop->Data);
00105   NewHead = New;
00106 
00107   Hop = Hop->Next;
00108   while(Hop)
00109     {
00110       Previous = New;
00111       New = new DLListNode<T>(Hop->Data);
00112       New->Prev = Previous;
00113       Previous->Next = New;
00114       Hop = Hop->Next;
00115     }
00116 \end{verbatim}\normalsize 
\index{DLList@{DLList}!AddToFront@{AddToFront}}
\index{AddToFront@{AddToFront}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ bool DLList$<$ T $>$::Add\-To\-Front (const T \& {\em data})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a7}




Definition at line 41 of file dllist.inc.

Referenced by Segments::Add(), Stack::Push(), Process::add\-Child(), Grid::approx\_\-neighbor\_\-i(), Grid::approx\_\-neighbor\_\-p(), Grid::neighbor\_\-d(), Grid::neighbor\_\-i(), and Grid::neighbor\_\-p().\footnotesize\begin{verbatim}00042 {
00043   // Create a new node.
00044   //
00045   DLListNode<T> * New = new DLListNode<T>(data);
00046 
00047   // Make the node the new head of the list.
00048   //
00049   if(IsEmpty())
00050     {
00051       New->Next = 0;
00052       New->Prev = 0;
00053       the_rep->Head = New;
00054       the_rep->Tail = New;
00055     }
00056   else
00057     {
00058       the_rep->Head->Prev = New;
00059       New->Next  = the_rep->Head;
00060       New->Prev  = 0;
00061       the_rep->Head = New;
00062     }
00063 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Clear@{Clear}}
\index{Clear@{Clear}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ void DLList$<$ T $>$::Clear ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a5}




Definition at line 33 of file dllist.inc.

Referenced by Segments::Clear(), Input\-Binary(), Segments::QSort\-Reduce(), Id\-Gen::Reset(), bf\_\-iterator::reset(), and df\_\-iterator::reset().\footnotesize\begin{verbatim}00034   { delete the_rep->Head; the_rep->Head=0; the_rep->Tail=0; the_rep->M=0; }
00035 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Find@{Find}}
\index{Find@{Find}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ const T \& DLList$<$ T $>$::Find (const T \& {\em data}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a28}




Definition at line 360 of file dllist.inc.\footnotesize\begin{verbatim}00361   { return Get( FindLocation(data) ); }
00362 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Find@{Find}}
\index{Find@{Find}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T \& DLList$<$ T $>$::Find (const T \& {\em data})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a27}




Definition at line 356 of file dllist.inc.\footnotesize\begin{verbatim}00357   { return Get( FindLocation(data) ); }
00358 \end{verbatim}\normalsize 
\index{DLList@{DLList}!FindLocation@{FindLocation}}
\index{FindLocation@{FindLocation}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ int DLList$<$ T $>$::Find\-Location (const T \& {\em data}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a29}




Definition at line 344 of file dllist.inc.

Referenced by Find(), In(), and Remove().\footnotesize\begin{verbatim}00345 {
00346   DLListNode<T> * Hop = the_rep->Head;
00347   for(int i=0; Hop; ++i)
00348     { 
00349       if(Hop->Data == data) return i;
00350       Hop = Hop->Next; 
00351     }
00352 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Get@{Get}}
\index{Get@{Get}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T \& DLList$<$ T $>$::Get (int {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a18}




Definition at line 252 of file dllist.inc.\footnotesize\begin{verbatim}00253 {
00254   if((i>=the_rep->M) || (i<0)) i=0;
00255 
00256   DLListNode<T> * Hop;
00257   if(i<the_rep->M/2)
00258     {
00259       Hop = the_rep->Head;
00260       for(int j=0; j<i; ++j) 
00261           Hop = Hop->Next;
00262     }
00263   else
00264     {
00265       Hop = the_rep->Tail;
00266       for(int j=the_rep->M-1; j>i; --j) 
00267           Hop = Hop->Prev;
00268     }
00269 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Get@{Get}}
\index{Get@{Get}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ const T \& DLList$<$ T $>$::Get (int {\em i}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a17}




Definition at line 231 of file dllist.inc.

Referenced by Find(), Segments::Get\-Seg(), Stack::Peek(), Segments::QSort\-Reduce\-Viol(), and Process::run\-Child().\footnotesize\begin{verbatim}00232 {
00233   if((i>=the_rep->M) || (i<0)) i=0;
00234 
00235   DLListNode<T> * Hop;
00236   if(i<the_rep->M/2)
00237     {
00238       Hop = the_rep->Head;
00239       for(int j=0; j<i; ++j) 
00240           Hop = Hop->Next;
00241     }
00242   else
00243     {
00244       Hop = the_rep->Tail;
00245       for(int j=the_rep->M-1; j>i; --j) 
00246           Hop = Hop->Prev;
00247     }
00248 \end{verbatim}\normalsize 
\index{DLList@{DLList}!GetConstIterator@{GetConstIterator}}
\index{GetConstIterator@{GetConstIterator}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$ T $>$::{\bf Const\-Iterator} DLList$<$T$>$::Get\-Const\-Iterator$<$T$>$ () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a35}




Definition at line 170 of file dllist.h.

Referenced by gw\-Numerics::add\-VDWSegments(), Constraint\-Manager::get\-Assoc\-Atoms(), and Molecule::read\-Fasta().\footnotesize\begin{verbatim}00171                   { return DLList<T>::ConstIterator(*this); }
00172 \end{verbatim}\normalsize 
\index{DLList@{DLList}!GetIterator@{GetIterator}}
\index{GetIterator@{GetIterator}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$ T $>$::{\bf Iterator} DLList$<$T$>$::Get\-Iterator$<$T$>$ ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a34}




Definition at line 167 of file dllist.h.

Referenced by Output\-Binary(), and path\_\-iterator::path\_\-iterator().\footnotesize\begin{verbatim}00168                   { return DLList<T>::Iterator(*this); }
00169 \end{verbatim}\normalsize 
\index{DLList@{DLList}!In@{In}}
\index{In@{In}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ int DLList$<$ T $>$::In (const T \& {\em data}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a30}




Definition at line 364 of file dllist.inc.\footnotesize\begin{verbatim}00365   { return (FindLocation(data) != -1); }
00366 \end{verbatim}\normalsize 
\index{DLList@{DLList}!IsEmpty@{IsEmpty}}
\index{IsEmpty@{IsEmpty}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ int DLList$<$ T $>$::Is\-Empty () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a3}




Definition at line 29 of file dllist.inc.

Referenced by Add\-To\-Back(), Add\-To\-Front(), Id\-Gen::Get(), Id\-Gen::Peek(), main(), operator int(), bf\_\-iterator::operator++(), and df\_\-iterator::operator++().\footnotesize\begin{verbatim}00030   { return (the_rep->Head ? 0 : 1); }
00031 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Number@{Number}}
\index{Number@{Number}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ int DLList$<$ T $>$::Number () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a6}




Definition at line 37 of file dllist.inc.

Referenced by Molecule::Dyn\-Read(), Segments::Get\-Num(), Segments::Number(), Id\-Gen::Number\-Free(), Output\-Binary(), Segments::QSort\-Reduce(), Segments::QSort\-Reduce\-Viol(), Process::assert\-Order(), j\-Vector::dynread(), Int\-Vec::dynread(), Process::num\-Queued(), Molecule::read\-Fasta(), and Process::run\-Child().\footnotesize\begin{verbatim}00038   { return the_rep->M; }
00039 \end{verbatim}\normalsize 
\index{DLList@{DLList}!PeekBack@{PeekBack}}
\index{PeekBack@{PeekBack}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T \& DLList$<$ T $>$::Peek\-Back ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a22}




Definition at line 285 of file dllist.inc.\footnotesize\begin{verbatim}00286   { return the_rep->Tail->Data; }
00287 \end{verbatim}\normalsize 
\index{DLList@{DLList}!PeekBack@{PeekBack}}
\index{PeekBack@{PeekBack}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ const T \& DLList$<$ T $>$::Peek\-Back () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a21}




Definition at line 281 of file dllist.inc.

Referenced by Process::add\-Child().\footnotesize\begin{verbatim}00282   { return the_rep->Tail->Data; }
00283 \end{verbatim}\normalsize 
\index{DLList@{DLList}!PeekFront@{PeekFront}}
\index{PeekFront@{PeekFront}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T \& DLList$<$ T $>$::Peek\-Front ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a20}




Definition at line 277 of file dllist.inc.\footnotesize\begin{verbatim}00278   { return the_rep->Head->Data; }
00279 \end{verbatim}\normalsize 
\index{DLList@{DLList}!PeekFront@{PeekFront}}
\index{PeekFront@{PeekFront}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ const T \& DLList$<$ T $>$::Peek\-Front () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a19}




Definition at line 273 of file dllist.inc.

Referenced by Queue::Peek(), and Process::add\-Child().\footnotesize\begin{verbatim}00274   { return the_rep->Head->Data; }
00275 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Print@{Print}}
\index{Print@{Print}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ ostream \& DLList$<$ T $>$::Print (ostream \& {\em os}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a31}




Definition at line 372 of file dllist.inc.\footnotesize\begin{verbatim}00373 {
00374   DLListNode<T> * Hop = the_rep->Head;
00375   while(Hop)
00376   {
00377     os << Hop->Data << " -> ";
00378     Hop = Hop->Next;
00379   }
00380 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Remove@{Remove}}
\index{Remove@{Remove}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T DLList$<$ T $>$::Remove (const T \& {\em data})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a24}




Definition at line 368 of file dllist.inc.\footnotesize\begin{verbatim}00369   { return RemoveLocation( FindLocation(data) ); }
00370 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Remove@{Remove}}
\index{Remove@{Remove}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T DLList$<$ T $>$::Remove ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a16}




Reimplemented in {\bf Queue} {\rm (p.\,\pageref{class_Queue_a2})}.

Definition at line 227 of file dllist.inc.

Referenced by Molecule::read\-Fasta().\footnotesize\begin{verbatim}00228   { return RemoveFromFront(); }
00229 \end{verbatim}\normalsize 
\index{DLList@{DLList}!RemoveFromBack@{RemoveFromBack}}
\index{RemoveFromBack@{RemoveFromBack}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T DLList$<$ T $>$::Remove\-From\-Back ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a15}




Definition at line 202 of file dllist.inc.

Referenced by Remove\-Location(), Process::assert\-Order(), Process::clean\-Queue(), main(), Process::run\-Children(), Process::run\-Children\-Repeat\-First(), and Process::run\-Next\-Child().\footnotesize\begin{verbatim}00203 {
00204   T DeletedData;
00205 
00206   //  if(!the_rep->Tail) return DeletedData;  // gives warning
00207   if(the_rep->Tail){
00208  
00209     DLListNode<T> * tmp = the_rep->Tail;
00210     the_rep->Tail = the_rep->Tail->Prev;
00211     if(the_rep->Tail) the_rep->Tail->Next = 0;
00212     else        the_rep->Head = 0;
00213 
00214     DeletedData = tmp->Data;
00215     tmp->Prev = 0;
00216     delete tmp;
00217     --the_rep->M;
00218     return DeletedData;
00219   } else {
00220     cerr << "called RemoveFromBack from empty dllist. __FILE__, __LINE__" << endl;
00221     raise (SIGQUIT);
00222     return the_rep->Head->Data; // GD useless line -- warning removal only
00223   }
00224 \end{verbatim}\normalsize 
\index{DLList@{DLList}!RemoveFromFront@{RemoveFromFront}}
\index{RemoveFromFront@{RemoveFromFront}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T DLList$<$ T $>$::Remove\-From\-Front ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a14}




Definition at line 176 of file dllist.inc.

Referenced by Molecule::Dyn\-Read(), Stack::Pop(), Segments::Pop(), Segments::QSort\-Reduce(), Queue::Remove(), Remove(), Remove\-Location(), j\-Vector::dynread(), Int\-Vec::dynread(), and main().\footnotesize\begin{verbatim}00177 {
00178   T DeletedData;
00179 
00180   //  if(!the_rep->Head) return DeletedData; // gives warning for non-init
00181 
00182   if(the_rep->Head){
00183 
00184     DLListNode<T> * tmp = the_rep->Head;
00185     the_rep->Head = the_rep->Head->Next;
00186     if(the_rep->Head) the_rep->Head->Prev = 0;
00187     else           the_rep->Tail = 0;
00188 
00189     DeletedData = tmp->Data;
00190     tmp->Next = 0;
00191     delete tmp;
00192     --the_rep->M;
00193     return DeletedData;
00194   } else {
00195     cerr << "called RemoveFromFront from empty dllist. __FILE__, __LINE__" << endl;
00196     raise (SIGQUIT);
00197     return the_rep->Head->Data; // GD useless line -- warning removal only
00198   }
00199 \end{verbatim}\normalsize 
\index{DLList@{DLList}!RemoveLocation@{RemoveLocation}}
\index{RemoveLocation@{RemoveLocation}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ T DLList$<$ T $>$::Remove\-Location (int {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a23}




Definition at line 290 of file dllist.inc.

Referenced by Remove().\footnotesize\begin{verbatim}00291 {
00292   if(i<=0) { return RemoveFromFront(); }
00293   if(i>=the_rep->M-1) { return RemoveFromBack(); }
00294 
00295   DLListNode<T> * Hop;
00296   if(i<the_rep->M/2)
00297     {
00298       Hop = the_rep->Head;
00299       for(int j=0; j<i; ++j) 
00300           Hop = Hop->Next;
00301     }
00302   else
00303     {
00304       Hop = the_rep->Tail;
00305       for(int j=the_rep->M-1; j>i; --j) 
00306           Hop = Hop->Prev;
00307     }
00308 \end{verbatim}\normalsize 
\index{DLList@{DLList}!UniqueCopy@{UniqueCopy}}
\index{UniqueCopy@{UniqueCopy}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$ T $>$ DLList$<$ T $>$::Unique\-Copy () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a32}




Definition at line 446 of file dllist.inc.

Referenced by Add\-To\-Back(), and Add\-To\-Front().\footnotesize\begin{verbatim}00447   {
00448     DLList<T> dll;
00449     DLListNode<T> * Hop = the_rep->Head;
00450     while(Hop)
00451       {
00452         dll.AddToBack(Hop->Data);
00453         Hop = Hop->Next;
00454       }
00455 \end{verbatim}\normalsize 
\index{DLList@{DLList}!operator int@{operator int}}
\index{operator int@{operator int}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ DLList$<$T$>$::operator int () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a4}




Definition at line 94 of file dllist.h.\footnotesize\begin{verbatim}00095                   { return !IsEmpty(); }
00096 \end{verbatim}\normalsize 
\index{DLList@{DLList}!operator"!=@{operator"!=}}
\index{operator"!=@{operator"!=}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ int DLList$<$ T $>$::operator!= (const DLList$<$ T $>$ \& {\em dll}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a26}




Definition at line 340 of file dllist.inc.\footnotesize\begin{verbatim}00341   { return !( this->operator==(dll) ); }
00342 \end{verbatim}\normalsize 
\index{DLList@{DLList}!operator+=@{operator+=}}
\index{operator+=@{operator+=}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ const DLList$<$ T $>$ \& DLList$<$ T $>$::operator+= (const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a13}




Definition at line 166 of file dllist.inc.\footnotesize\begin{verbatim}00167   { AddToBack(dll); return *this; }
00168 \end{verbatim}\normalsize 
\index{DLList@{DLList}!operator=@{operator=}}
\index{operator=@{operator=}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ const DLList$<$ T $>$ \& DLList$<$ T $>$::operator= (const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a33}




Definition at line 435 of file dllist.inc.\footnotesize\begin{verbatim}00436   {
00437     if(the_rep == dll.the_rep) return *this;
00438 
00439     if(the_rep) the_rep->Dereference();
00440     the_rep = dll.the_rep;
00441     if(the_rep) the_rep->Reference();
00442     return *this;
00443 \end{verbatim}\normalsize 
\index{DLList@{DLList}!operator==@{operator==}}
\index{operator==@{operator==}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ int DLList$<$ T $>$::operator== (const DLList$<$ T $>$ \& {\em dll}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DLList_a25}




Definition at line 323 of file dllist.inc.

Referenced by operator!=().\footnotesize\begin{verbatim}00324   {
00325     if(the_rep->M != dll.the_rep->M) return 0;
00326     if(the_rep->M == 0) return 1;
00327 
00328     DLListNode<T> * Hop1 = the_rep->Head;
00329     DLListNode<T> * Hop2 = dll.the_rep->Head;
00330     while(Hop1)
00331       {
00332         if(Hop1->Data != Hop2->Data) return 0;
00333         Hop1 = Hop1->Next;
00334         Hop2 = Hop2->Next;
00335       }
00336 \end{verbatim}\normalsize 


\subsection{Friends And Related Function Documentation}
\index{DLList@{DLList}!ConstIterator@{ConstIterator}}
\index{ConstIterator@{ConstIterator}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ class Const\-Iterator\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l1}




Definition at line 82 of file dllist.h.

Referenced by Get\-Const\-Iterator().\index{DLList@{DLList}!InputBinary@{InputBinary}}
\index{InputBinary@{InputBinary}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ istream\& Input\-Binary (istream \& {\em is}, DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l3}




Definition at line 389 of file dllist.inc.\footnotesize\begin{verbatim}00390   {
00391     // Delete everything:
00392     //
00393     dll.Clear();
00394 
00395     // Read in the number of elements:
00396     //
00397     int numel;
00398     if(InputBinary(is,numel).bad())
00399         return is;
00400 
00401     T stuff;
00402     for(int i=0; i<numel; ++i)
00403       {
00404         if(InputBinary(is,stuff).bad())
00405             return is;
00406         dll.AddToBack(stuff);
00407       }
00408 \end{verbatim}\normalsize 
\index{DLList@{DLList}!Iterator@{Iterator}}
\index{Iterator@{Iterator}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ class Iterator\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l0}




Definition at line 81 of file dllist.h.

Referenced by Get\-Iterator().\index{DLList@{DLList}!OutputBinary@{OutputBinary}}
\index{OutputBinary@{OutputBinary}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ ostream\& Output\-Binary (ostream \& {\em os}, const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l5}




Definition at line 412 of file dllist.inc.\footnotesize\begin{verbatim}00413   {
00414     // Write the number of elements:
00415     //
00416     if(OutputBinary(os, dll.Number()).bad())
00417         return os;
00418 
00419     for(DLList<T>::Iterator it = dll.GetIterator(); it; ++it)
00420         if(OutputBinary(os, *it).bad())
00421             return os;
00422     return os;
00423 \end{verbatim}\normalsize 
\index{DLList@{DLList}!operator@{operator}}
\index{operator@{operator}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ ostream\& operator (ostream \& {\em os}, const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l6}


\index{DLList@{DLList}!operator@{operator}}
\index{operator@{operator}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ ostream\& operator (ostream \& {\em os}, const DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l2}


\index{DLList@{DLList}!operator>=@{operator$>$=}}
\index{operator>=@{operator$>$=}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ istream\& operator$>$= (istream \& {\em is}, DLList$<$ T $>$ \& {\em dll})\hspace{0.3cm}{\tt  [friend]}}\label{class_DLList_l4}




Definition at line 427 of file dllist.inc.\footnotesize\begin{verbatim}00428   { return InputBinary(os,dll); }
00429 \end{verbatim}\normalsize 


\subsection{Member Data Documentation}
\index{DLList@{DLList}!the_rep@{the\_\-rep}}
\index{the_rep@{the\_\-rep}!DLList@{DLList}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T$>$ {\bf DLList\-Rep}$<$ T $>$ $\ast$ DLList$<$T$>$::the\_\-rep\hspace{0.3cm}{\tt  [private]}}\label{class_DLList_o0}




Definition at line 174 of file dllist.h.

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
{\bf dllist.h}\item 
{\bf dllist.inc}\end{CompactItemize}
