\section{Dyn\-String  Class Reference}
\label{class_DynString}\index{DynString@{Dyn\-String}}
{\tt \#include $<$dynstring.h$>$}

Collaboration diagram for Dyn\-String:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=72pt]{class_DynString_coll_graph}
\end{center}
\end{figure}
\subsection*{Public Methods}
\begin{CompactItemize}
\item 
{\bf Dyn\-String} ()
\item 
{\bf Dyn\-String} (const char $\ast$str)
\item 
{\bf Dyn\-String} (const Dyn\-String \&ds)
\item 
{\bf Dyn\-String} (char c)
\item 
{\bf Dyn\-String} (int i)
\item 
{\bf Dyn\-String} (double d)
\item 
{\bf $\sim$Dyn\-String} ()
\item 
int {\bf Is\-Bad} () const
\item 
int {\bf Dest\-Resize\-To\-Fit} (int nchars)
\item 
int {\bf Non\-Dest\-Resize\-To\-Fit} (int nchars)
\item 
int {\bf Resize} (int newlength)
\item 
int {\bf Set} (const Dyn\-String \&ds)
\item 
int {\bf Set} (const char $\ast$str, int numchars)
\item 
int {\bf Set} (int i, char c)
\item 
int {\bf Chop} (int n=1)
\item 
void {\bf Clear} ()
\item 
const Dyn\-String\& {\bf Cat} (char c)
\item 
const Dyn\-String\& {\bf Cat} (const char $\ast$str)
\item 
const Dyn\-String\& {\bf Cat} (const Dyn\-String \&ds)
\item 
Dyn\-String {\bf Sub} (int i, int j) const
\item 
Dyn\-String {\bf operator()} (int i, int j) const
\item 
int {\bf Is\-Sub} (const Dyn\-String \&substr) const
\item 
int {\bf Replace} (const Dyn\-String \&oldstr, const Dyn\-String \&newstr)
\item 
void {\bf To\-Upper} ()
\item 
void {\bf To\-Lower} ()
\item 
double {\bf To\-Dbl} () const
\item 
int {\bf To\-Int} () const
\item 
int {\bf Compare} (const Dyn\-String \&ds) const
\item 
const char$\ast$ {\bf Get\-Data} () const
\item 
char$\ast$ {\bf Get\-Data\-Copy} () const
\item 
int {\bf Length} () const
\item 
int {\bf Bytes} () const
\item 
int {\bf Blocks} () const
\item 
const Dyn\-String\& {\bf Pad} (char c, int n)
\item 
const Dyn\-String\& {\bf operator+=} (const Dyn\-String \&ds)
\item 
const char\& {\bf operator[$\,$]} (int i) const
\item 
char\& {\bf operator[$\,$]} (int i)
\item 
const Dyn\-String\& {\bf operator=} (const Dyn\-String \&ds)
\item 
const Dyn\-String\& {\bf operator=} (const char $\ast$str)
\item 
const Dyn\-String\& {\bf operator=} (char c)
\item 
const Dyn\-String\& {\bf operator=} (double number)
\item 
int {\bf Get\-Char} (istream \&is)
\item 
int {\bf Read} (istream \&is, bool append=false)
\item 
int {\bf Split} (Dyn\-String $\ast$\&substr) const
\item 
int {\bf Output} (ostream \&os) const
\item 
int {\bf Input} (istream \&is)
\item 
int {\bf Input\-Binary} (istream \&is)
\item 
int {\bf Output\-Binary} (ostream \&os) const
\item 
{\bf MAKECOMPARISONS\_\-WITH\_\-COMPARE} (Dyn\-String)
\item 
{\bf MAKE\_\-IO\_\-STREAM\_\-OPERATORS} (Dyn\-String)
\item 
{\bf MAKE\_\-BIN\_\-STREAM\_\-OPERATORS} (Dyn\-String)
\item 
istream\& {\bf Read\-Line} (istream \&is, bool append=false)
\item 
void {\bf Eat\-Line} (istream \&is) const
\end{CompactItemize}
\subsection*{Static Public Attributes}
\begin{CompactItemize}
\item 
char$\ast$ {\bf Bad} = 0
\item 
const int {\bf Block\-Size} = 32
\item 
int {\bf Delimiter} [256]
\item 
Dyn\-String {\bf Empty} = ""
\end{CompactItemize}
\subsection*{Private Methods}
\begin{CompactItemize}
\item 
void {\bf Make\-Bad} ()
\item 
int {\bf Dest\-Resize} (int nblocks)
\item 
int {\bf Non\-Dest\-Resize} (int nblocks)
\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
char$\ast$ {\bf innards}
\item 
int {\bf N}
\item 
int {\bf L}
\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
void {\bf Set\-DSDelim} (const Dyn\-String \&delim)
\item 
void {\bf Add\-DSDelim} (char delim)
\item 
void {\bf Rem\-DSDelim} (char delim)
\item 
Dyn\-String {\bf Get\-DSDelim} ()
\item 
Dyn\-String {\bf Int\-To\-DS} (int i)
\item 
Dyn\-String {\bf Reproduce} (char c, int n)
\item 
Dyn\-String {\bf operator+} (Dyn\-String x, const Dyn\-String \&y)
\item 
int {\bf DSprintf} (Dyn\-String \&ds, const char $\ast$cntl,...)
\end{CompactItemize}


\subsection{Constructor \& Destructor Documentation}
\index{DynString@{Dyn\-String}!DynString@{DynString}}
\index{DynString@{DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::Dyn\-String ()}\label{class_DynString_a0}




Definition at line 186 of file dynstring.C.

Referenced by Eat\-Line(), and Read\-Line().\footnotesize\begin{verbatim}00187   {
00188     innards = 0; N = 0; L = 0;
00189     if(!DestResize(1)) MakeBad();
00190 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DynString@{DynString}}
\index{DynString@{DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::Dyn\-String (const char $\ast$ {\em str})}\label{class_DynString_a1}




Definition at line 192 of file dynstring.C.\footnotesize\begin{verbatim}00193   {
00194     innards = 0; N = 0; L = 0;
00195     Set(str,strlen(str));
00196 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DynString@{DynString}}
\index{DynString@{DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::Dyn\-String (const Dyn\-String \& {\em ds})}\label{class_DynString_a2}




Definition at line 198 of file dynstring.C.\footnotesize\begin{verbatim}00199   {
00200     innards = 0; N = 0; L = 0;
00201     Set(ds);
00202 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DynString@{DynString}}
\index{DynString@{DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::Dyn\-String (char {\em c})}\label{class_DynString_a3}




Definition at line 204 of file dynstring.C.\footnotesize\begin{verbatim}00205   {
00206     innards = 0; N = 0; L = 0;
00207     char * str = new char[2];
00208     str[0] = c; str[1] = 0;
00209     Set(str,1);
00210     delete str;
00211 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DynString@{DynString}}
\index{DynString@{DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::Dyn\-String (int {\em i})}\label{class_DynString_a4}




Definition at line 213 of file dynstring.C.\footnotesize\begin{verbatim}00214   {
00215     innards = 0; N = 0; L = 0;
00216     char * str = new char[100];
00217     sprintf(str, "%i", i);
00218     Set(str,strlen(str));
00219     delete str;
00220 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DynString@{DynString}}
\index{DynString@{DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::Dyn\-String (double {\em d})}\label{class_DynString_a5}




Definition at line 222 of file dynstring.C.\footnotesize\begin{verbatim}00223   {
00224     innards = 0; N = 0; L = 0;
00225     char * str = new char[100];
00226     sprintf(str, "%g", d);
00227     Set(str,strlen(str));
00228     delete str;
00229 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!~DynString@{$\sim$DynString}}
\index{~DynString@{$\sim$DynString}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::$\sim$Dyn\-String ()}\label{class_DynString_a6}




Definition at line 231 of file dynstring.C.\footnotesize\begin{verbatim}00232 {
00233   if(!IsBad()) delete[] innards;
00234 \end{verbatim}\normalsize 


\subsection{Member Function Documentation}
\index{DynString@{Dyn\-String}!Blocks@{Blocks}}
\index{Blocks@{Blocks}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Blocks () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a32}




Definition at line 141 of file dynstring.h.\footnotesize\begin{verbatim}00142   { return N; }
00143 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Bytes@{Bytes}}
\index{Bytes@{Bytes}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Bytes () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a31}




Definition at line 138 of file dynstring.h.\footnotesize\begin{verbatim}00139   { return N*BlockSize; }
00140 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Cat@{Cat}}
\index{Cat@{Cat}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::Cat (const Dyn\-String \& {\em ds})}\label{class_DynString_a18}




Definition at line 106 of file dynstring.C.\footnotesize\begin{verbatim}00107   {
00108     if(IsBad() || ds.IsBad()) return *this;
00109     int newlen = L+ds.L;
00110     if(!NonDestResizeToFit(newlen)) return *this;
00111     strncat(innards, ds.innards, ds.L);
00112     L += ds.L;
00113     innards[L] = '\0';
00114     return *this;
00115 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Cat@{Cat}}
\index{Cat@{Cat}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String\& Dyn\-String::Cat (const char $\ast$ {\em str})}\label{class_DynString_a17}


\index{DynString@{Dyn\-String}!Cat@{Cat}}
\index{Cat@{Cat}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::Cat (char {\em c})}\label{class_DynString_a16}




Definition at line 97 of file dynstring.C.

Referenced by Get\-Char(), Pad(), Read(), Split(), and operator+=().\footnotesize\begin{verbatim}00098   {
00099     if(IsBad()) return *this;
00100     if(!NonDestResizeToFit(L+1)) return *this;
00101     innards[L++] = c;
00102     innards[L]   = '\0';
00103     return *this;
00104 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Chop@{Chop}}
\index{Chop@{Chop}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Chop (int {\em n} = 1)}\label{class_DynString_a14}




Definition at line 175 of file dynstring.C.\footnotesize\begin{verbatim}00176   {
00177     if(IsBad() || n<0) return 0;
00178     if(n==0) return L;
00179     n = (n<=L) ? n : L;
00180     NonDestResizeToFit(L-n);
00181     L = L-n;
00182     innards[L] = '\0';
00183     return L;
00184 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Clear@{Clear}}
\index{Clear@{Clear}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Dyn\-String::Clear ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a15}




Definition at line 83 of file dynstring.h.

Referenced by Read(), Residue::Residue(), and Molecule::read\-Fasta().\footnotesize\begin{verbatim}00084   { 
00085     if(!DestResize(1)) MakeBad();
00086     else { L=0; innards[0] = '\0'; }
00087 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Compare@{Compare}}
\index{Compare@{Compare}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Compare (const Dyn\-String \& {\em ds}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a27}




Definition at line 122 of file dynstring.h.\footnotesize\begin{verbatim}00123   { return strcmp(innards,ds.innards); }
00124 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DestResize@{DestResize}}
\index{DestResize@{DestResize}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Dest\-Resize (int {\em nblocks})\hspace{0.3cm}{\tt  [private]}}\label{class_DynString_c1}




Definition at line 69 of file dynstring.C.

Referenced by Clear(), Dest\-Resize\-To\-Fit(), Dyn\-String(), and Set().\footnotesize\begin{verbatim}00070   {
00071     if(N == nblocks) return 1;
00072     if(nblocks<1) return 0;
00073     char * tmp = innards;
00074     if(!(innards = new char[nblocks*BlockSize]))
00075       { innards = tmp; return 0; }
00076 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DestResizeToFit@{DestResizeToFit}}
\index{DestResizeToFit@{DestResizeToFit}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Dest\-Resize\-To\-Fit (int {\em nchars})\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a8}




Definition at line 45 of file dynstring.h.

Referenced by Ran\-Word::Get(), Get\-DSDelim(), Input\-Binary(), Replace(), Reproduce(), Set(), Sub(), and operator=().\footnotesize\begin{verbatim}00046   { return DestResize((nchars/BlockSize)+1); }
00047 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!EatLine@{EatLine}}
\index{EatLine@{EatLine}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Dyn\-String::Eat\-Line (istream \& {\em is}) const}\label{class_DynString_a52}




Definition at line 770 of file dynstring.C.

Referenced by main().\footnotesize\begin{verbatim}00771   { DynString().ReadLine(is); }
00772 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!GetChar@{GetChar}}
\index{GetChar@{GetChar}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Get\-Char (istream \& {\em is})}\label{class_DynString_a41}




Definition at line 451 of file dynstring.C.

Referenced by Molecule::read\-Fasta().\footnotesize\begin{verbatim}00452   {
00453     char c;
00454     is.get(c);
00455     if(is.eof() || is.bad()) return 0;
00456     Cat(c);
00457     return 1;
00458 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!GetData@{GetData}}
\index{GetData@{GetData}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const char $\ast$ Dyn\-String::Get\-Data () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a28}




Definition at line 128 of file dynstring.h.

Referenced by main().\footnotesize\begin{verbatim}00129   { return innards; }
00130 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!GetDataCopy@{GetDataCopy}}
\index{GetDataCopy@{GetDataCopy}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Dyn\-String::Get\-Data\-Copy () const}\label{class_DynString_a29}




Definition at line 412 of file dynstring.C.\footnotesize\begin{verbatim}00413   {
00414     if(IsBad()) return Bad;
00415     char * s = new char[L+1];
00416     strncpy(s,innards,L);
00417     s[L]='\0';
00418     return s;
00419 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Input@{Input}}
\index{Input@{Input}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Input (istream \& {\em is})}\label{class_DynString_a45}




Definition at line 742 of file dynstring.C.\footnotesize\begin{verbatim}00743   { return Read(is); }
00744 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!InputBinary@{InputBinary}}
\index{InputBinary@{InputBinary}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Input\-Binary (istream \& {\em is})}\label{class_DynString_a46}




Definition at line 421 of file dynstring.C.\footnotesize\begin{verbatim}00422   {
00423     // Delete everything
00424     //
00425     delete[] innards; innards = 0;
00426     N = 0;
00427     L = 0;
00428 
00429     int num_chars=0;
00430     is >= num_chars;
00431 
00432     if(!DestResizeToFit(num_chars))
00433         { cerr << "DynString::InputBinary\n"; raise(SIGQUIT); }
00434 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!IsBad@{IsBad}}
\index{IsBad@{IsBad}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Is\-Bad () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a7}




Definition at line 41 of file dynstring.h.

Referenced by Cat(), Chop(), Get\-Data\-Copy(), Is\-Sub(), Output(), Set(), Sub(), and $\sim$Dyn\-String().\footnotesize\begin{verbatim}00042   { return (innards == Bad); }
00043 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!IsSub@{IsSub}}
\index{IsSub@{IsSub}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Is\-Sub (const Dyn\-String \& {\em substr}) const}\label{class_DynString_a21}




Definition at line 266 of file dynstring.C.\footnotesize\begin{verbatim}00267   {
00268     if(IsBad() || substr.IsBad()) return 0;
00269 
00270     int match;
00271     for(int i=0; i<L-substr.L+1; ++i)
00272       {
00273         match = 1;
00274         for(int j=0; j<substr.L; ++j)
00275             if(innards[i+j] != substr.innards[j]) { match = 0; break; }
00276         if(match) return 1;
00277       }
00278 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Length@{Length}}
\index{Length@{Length}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Length () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a30}




Definition at line 135 of file dynstring.h.

Referenced by DSIterator::Delim\-Match(), DSIterator::Position(), Replace(), Atom\-Registry::Set\-Type(), Anim\-Frame::Set\_\-Output\_\-Stream(), and DSIterator::operator int().\footnotesize\begin{verbatim}00136   { return L; }
00137 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!MAKECOMPARISONS_WITH_COMPARE@{MAKECOMPARISONS\_\-WITH\_\-COMPARE}}
\index{MAKECOMPARISONS_WITH_COMPARE@{MAKECOMPARISONS\_\-WITH\_\-COMPARE}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::MAKECOMPARISONS\_\-WITH\_\-COMPARE (Dyn\-String)}\label{class_DynString_a48}


\index{DynString@{Dyn\-String}!MAKE_BIN_STREAM_OPERATORS@{MAKE\_\-BIN\_\-STREAM\_\-OPERATORS}}
\index{MAKE_BIN_STREAM_OPERATORS@{MAKE\_\-BIN\_\-STREAM\_\-OPERATORS}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::MAKE\_\-BIN\_\-STREAM\_\-OPERATORS (Dyn\-String)}\label{class_DynString_a50}


\index{DynString@{Dyn\-String}!MAKE_IO_STREAM_OPERATORS@{MAKE\_\-IO\_\-STREAM\_\-OPERATORS}}
\index{MAKE_IO_STREAM_OPERATORS@{MAKE\_\-IO\_\-STREAM\_\-OPERATORS}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String::MAKE\_\-IO\_\-STREAM\_\-OPERATORS (Dyn\-String)}\label{class_DynString_a49}


\index{DynString@{Dyn\-String}!MakeBad@{MakeBad}}
\index{MakeBad@{MakeBad}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Dyn\-String::Make\-Bad ()\hspace{0.3cm}{\tt  [inline, private]}}\label{class_DynString_c0}




Definition at line 223 of file dynstring.h.

Referenced by Clear(), Dyn\-String(), Set(), Sub(), and operator=().\footnotesize\begin{verbatim}00224   { N=0; L=0; delete[] innards; innards = Bad; }
00225 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!NonDestResize@{NonDestResize}}
\index{NonDestResize@{NonDestResize}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Non\-Dest\-Resize (int {\em nblocks})\hspace{0.3cm}{\tt  [private]}}\label{class_DynString_c2}




Definition at line 81 of file dynstring.C.

Referenced by Non\-Dest\-Resize\-To\-Fit().\footnotesize\begin{verbatim}00082   {
00083     if(N == nblocks) return 1;
00084     if(nblocks<1) return 0;
00085     char * tmp = innards;
00086     if(!(innards = new char[nblocks*BlockSize]))
00087       { innards = tmp; return 0; }
00088 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!NonDestResizeToFit@{NonDestResizeToFit}}
\index{NonDestResizeToFit@{NonDestResizeToFit}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Non\-Dest\-Resize\-To\-Fit (int {\em nchars})\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a9}




Definition at line 47 of file dynstring.h.

Referenced by Cat(), Chop(), Resize(), Set(), and operator[$\,$]().\footnotesize\begin{verbatim}00048   { return NonDestResize((nchars/BlockSize)+1); }
00049 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Output@{Output}}
\index{Output@{Output}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Output (ostream \& {\em os}) const}\label{class_DynString_a44}




Definition at line 733 of file dynstring.C.\footnotesize\begin{verbatim}00734   { 
00735     if(IsBad())
00736         os << "<<BAD STRING!>>";
00737     else
00738         os << innards; 
00739     return L; 
00740 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!OutputBinary@{OutputBinary}}
\index{OutputBinary@{OutputBinary}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Output\-Binary (ostream \& {\em os}) const}\label{class_DynString_a47}




Definition at line 443 of file dynstring.C.\footnotesize\begin{verbatim}00444   {
00445     os <= L;
00446     if(L>0)
00447         os.write(innards, L*sizeof(char));
00448     return L;
00449 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Pad@{Pad}}
\index{Pad@{Pad}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::Pad (char {\em c}, int {\em n})}\label{class_DynString_a33}




Definition at line 755 of file dynstring.C.\footnotesize\begin{verbatim}00756   {
00757     DynString padding = Reproduce(c,n);
00758     return Cat(padding);
00759 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Read@{Read}}
\index{Read@{Read}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Read (istream \& {\em is}, bool {\em append} = false)}\label{class_DynString_a42}




Definition at line 460 of file dynstring.C.

Referenced by Input(), and Read\-Line().\footnotesize\begin{verbatim}00461   {
00462     char c;
00463     int len=0;
00464     
00465     if(!append) Clear();
00466 
00467     is.unsetf(ios::skipws);
00468     // Skip all the header delimiter characters.
00469     for(int done=0; !done; )
00470       {
00471         c = is.peek();
00472 
00473         // See if the character matches any delimiter character.
00474         if(c == EOF || !Delimiter[(uint) c]) done = 1;
00475 
00476         // Otherwise advance to the next character in the stream.
00477         else is.get();
00478       }
00479 
00480     // Read in a series of consecutive non-delimiter characters.
00481     for(int done=0; !done; )
00482       {
00483         c = is.peek();
00484         if((c == EOF) || Delimiter[(uint) c]) done = 1;
00485         else
00486           {
00487             Cat(c);
00488             is.get();
00489             ++len;
00490           }
00491       }
00492 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!ReadLine@{ReadLine}}
\index{ReadLine@{ReadLine}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}istream \& Dyn\-String::Read\-Line (istream \& {\em is}, bool {\em append} = false)}\label{class_DynString_a51}




Definition at line 761 of file dynstring.C.

Referenced by Eat\-Line(), Molecule::read\-Fasta(), Molecule::read\-Xmol(), and Molecule::skip\-Xmol().\footnotesize\begin{verbatim}00762   {
00763     DynString old_delim = GetDSDelim();
00764     SetDSDelim(DynString("\n"));
00765     Read(is,append);
00766     SetDSDelim(old_delim);
00767     return is;
00768 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Replace@{Replace}}
\index{Replace@{Replace}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Replace (const Dyn\-String \& {\em oldstr}, const Dyn\-String \& {\em newstr})}\label{class_DynString_a22}




Definition at line 281 of file dynstring.C.\footnotesize\begin{verbatim}00282   {
00283     int oldlen = oldstr.Length(), newlen = newstr.Length();
00284     int * match = 0;
00285     int replace=0;
00286     int total=-1;
00287 
00288     if(L<1 || oldlen<1) return 0;
00289 
00290     if(!(match = new int[L]))
00291         { cerr << "DynString::Replace#1\n"; raise(SIGQUIT); }
00292 
00293     if(oldlen < 1) return 0;
00294 
00295     // Find the number of (non-overlapping replacements we need to make):
00296     for(int i=0; i<L; ++i) match[i] = 0;
00297     for(int i=0; i<L-oldlen+1; )
00298       {
00299         if(!strncmp(innards+i, oldstr.innards, oldlen))
00300           {
00301             // Found a match!
00302             ++replace;
00303             match[i] = 1;
00304             i += oldlen;
00305           }
00306         else 
00307           { match[i] = 0; ++i; }
00308       }
00309     
00310     total = L + replace*(newlen-oldlen);
00311 
00312     if(total<1) 
00313       {
00314         delete[] match;
00315         return 0;
00316       }
00317 
00318     // Copy the old string.
00319     char * oldinnards = 0;
00320     if(!(oldinnards = new char[L+1]))
00321         { cerr << "DynString::Replace#2\n"; raise(SIGQUIT); }
00322     int oldL = L;
00323     for(int i=0; i<oldL; ++i) oldinnards[i] = innards[i];
00324     oldinnards[oldL] = '\0';
00325 
00326     // Make space for the new string.
00327     if(!DestResizeToFit(total))
00328         { cerr << "DynString::Replace#3\n"; raise(SIGQUIT); }
00329     
00330     int j=0;
00331     for(int i=0; i<oldL; )
00332       {
00333         if(match[i])
00334           {
00335             for(int k=0; k<newlen; ++k)
00336                 innards[j++] = newstr[k];
00337             i += oldlen;
00338           }
00339         else
00340             innards[j++] = oldinnards[i++];
00341       }
00342 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Resize@{Resize}}
\index{Resize@{Resize}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Resize (int {\em newlength})\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a10}




Definition at line 49 of file dynstring.h.\footnotesize\begin{verbatim}00050   { return NonDestResizeToFit(newlength); }
00051 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Set@{Set}}
\index{Set@{Set}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Set (int {\em i}, char {\em c})}\label{class_DynString_a13}




Definition at line 154 of file dynstring.C.\footnotesize\begin{verbatim}00155   {
00156     if(IsBad() || i<0) return 0;
00157     if(i>=N*BlockSize-1)
00158       {
00159         if(!NonDestResizeToFit(i)) 
00160           {
00161             MakeBad();
00162             return 0;
00163           }
00164       }
00165     if(i>=L)
00166       {
00167         innards[L] = innards[N*BlockSize-1];
00168         L = i+1;
00169         innards[L] = '\0';
00170       }
00171 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Set@{Set}}
\index{Set@{Set}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Set (const char $\ast$ {\em str}, int {\em num})}\label{class_DynString_a12}




Definition at line 136 of file dynstring.C.\footnotesize\begin{verbatim}00137   {
00138      if(!str || str == Bad)
00139       { MakeBad(); return 0; }
00140 
00141     if(num<=0)
00142       { DestResize(1); return 0; }
00143 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Set@{Set}}
\index{Set@{Set}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Set (const Dyn\-String \& {\em ds})}\label{class_DynString_a11}




Definition at line 117 of file dynstring.C.

Referenced by Dyn\-String(), and operator=().\footnotesize\begin{verbatim}00118   {
00119     if(this == &ds)
00120         return 1;
00121 
00122     if(ds.L<1)
00123       { DestResize(1); return 0; }
00124 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Split@{Split}}
\index{Split@{Split}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Split (Dyn\-String $\ast$\& {\em substr}) const}\label{class_DynString_a43}




Definition at line 496 of file dynstring.C.\footnotesize\begin{verbatim}00497   {
00498     // Number of substrings returned;
00499     int n=0;
00500 
00501     if(substr)
00502         delete[] substr;
00503     substr = 0;
00504 
00505     // Count the number of substrings there are:
00506     int i=0;
00507     while(i<L)
00508       {
00509         // Skip leading stretch of delimiters:
00510         for(; i<L; ++i)
00511           {
00512             if(!Delimiter[(uint) innards[i]])
00513                 break;
00514             cout << '<' << innards[i] << '>';
00515           }
00516         // Increment the substring count if there's still
00517         // characters left in the string:
00518         ++n;
00519 
00520         // Skip over this substring:
00521         for(; i<L; ++i)
00522           {
00523             if(Delimiter[(uint) innards[i]])
00524                 break;
00525             cout << '[' << innards[i] << ']';
00526           }
00527       }
00528 
00529     if(n < 1) 
00530         return 0;
00531     
00532     // Create space for the substrings:
00533     substr = new DynString[n];
00534 
00535     i=0;
00536     int j=-1;
00537     while(i<L)
00538       {
00539         // Skip all the header delimiter characters.
00540         for(i=0; i<L; ++i)
00541             // See if the character matches any delimiter.
00542             if(!Delimiter[(uint) innards[i]])
00543                 break;
00544 
00545         // Read in a series of consecutive non-delimiter.
00546         substr[++j] = "";
00547         for(; i<L; ++i)
00548           {
00549             if(Delimiter[(uint) innards[i]])
00550                 break;
00551             else
00552                 substr[j].Cat(innards[i]);
00553           }
00554       }
00555 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Sub@{Sub}}
\index{Sub@{Sub}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String Dyn\-String::Sub (int {\em i}, int {\em j}) const}\label{class_DynString_a19}




Definition at line 236 of file dynstring.C.

Referenced by operator()().\footnotesize\begin{verbatim}00237   {
00238     DynString substr = "";
00239     if(L <= 0) return substr;
00240     if(IsBad())
00241       {
00242         substr.MakeBad();
00243         return substr;
00244       }
00245 
00246     int k;
00247     if(j<i)
00248       {
00249         k = j;
00250         j = i;
00251         i = k;
00252       }
00253     
00254     if(i<0) i = 0;
00255     if(j >= L) j = L-1;
00256 
00257     if(!substr.DestResizeToFit(j-i+1))
00258         { cerr << "DynString::Sub\n"; raise(SIGQUIT); }
00259 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!ToDbl@{ToDbl}}
\index{ToDbl@{ToDbl}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double Dyn\-String::To\-Dbl () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a25}




Definition at line 114 of file dynstring.h.

Referenced by dd\-Graph::Input(), and main().\footnotesize\begin{verbatim}00115   { return atof(innards); }
00116 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!ToInt@{ToInt}}
\index{ToInt@{ToInt}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::To\-Int () const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a26}




Definition at line 116 of file dynstring.h.

Referenced by dd\-Graph::Input(), main(), Molecule::read\-Xmol(), and Molecule::skip\-Xmol().\footnotesize\begin{verbatim}00117   { return ((int) atoi(innards)); }
00118 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!ToLower@{ToLower}}
\index{ToLower@{ToLower}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Dyn\-String::To\-Lower ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a24}




Definition at line 110 of file dynstring.h.\footnotesize\begin{verbatim}00111   { for(int i=0; i<L; ++i) innards[i] = tolower(innards[i]); }
00112 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!ToUpper@{ToUpper}}
\index{ToUpper@{ToUpper}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Dyn\-String::To\-Upper ()\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a23}




Definition at line 108 of file dynstring.h.

Referenced by Molecule::read\-Fasta().\footnotesize\begin{verbatim}00109   { for(int i=0; i<L; ++i) innards[i] = toupper(innards[i]); }
00110 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator()@{operator()}}
\index{operator()@{operator()}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String Dyn\-String::operator() (int {\em i}, int {\em j}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a20}




Definition at line 96 of file dynstring.h.\footnotesize\begin{verbatim}00097   { return Sub(i,j); }
00098 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator+=@{operator+=}}
\index{operator+=@{operator+=}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::operator+= (const Dyn\-String \& {\em ds})\hspace{0.3cm}{\tt  [inline]}}\label{class_DynString_a34}




Definition at line 157 of file dynstring.h.\footnotesize\begin{verbatim}00158   { return Cat(ds); }
00159 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator=@{operator=}}
\index{operator=@{operator=}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::operator= (double {\em number})}\label{class_DynString_a40}




Definition at line 383 of file dynstring.C.\footnotesize\begin{verbatim}00384   {
00385     char * s = new char[30];
00386     sprintf(s, "%g", number);
00387     Set(s,strlen(s));
00388     delete[] s;
00389     return *this;
00390 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator=@{operator=}}
\index{operator=@{operator=}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::operator= (char {\em c})}\label{class_DynString_a39}




Definition at line 372 of file dynstring.C.\footnotesize\begin{verbatim}00373   {
00374     // Get rid of extra space if it is currently allocated.
00375     //
00376     if(!DestResizeToFit(1)) { MakeBad(); return *this; }
00377 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator=@{operator=}}
\index{operator=@{operator=}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::operator= (const char $\ast$ {\em str})}\label{class_DynString_a38}




Definition at line 369 of file dynstring.C.\footnotesize\begin{verbatim}00370   { if(innards != str) Set(str,strlen(str)); return *this; }
00371 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator=@{operator=}}
\index{operator=@{operator=}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const Dyn\-String \& Dyn\-String::operator= (const Dyn\-String \& {\em ds})}\label{class_DynString_a37}




Definition at line 362 of file dynstring.C.\footnotesize\begin{verbatim}00363   {
00364     if(!ds.innards) return ($\ast$this);
00365     Set(ds); 
00366     return *this;
00367 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char \& Dyn\-String::operator[$\,$] (int {\em i})}\label{class_DynString_a36}




Definition at line 399 of file dynstring.C.\footnotesize\begin{verbatim}00400   {
00401     if(i<0)
00402       { cerr << "DynString::operator[]\n"; raise(SIGQUIT); }
00403     if(i>=L) 
00404       {
00405         NonDestResizeToFit(i+1);
00406         L = i+1;
00407         innards[L] = '\0';
00408       }
00409 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const char \& Dyn\-String::operator[$\,$] (int {\em i}) const}\label{class_DynString_a35}




Definition at line 392 of file dynstring.C.\footnotesize\begin{verbatim}00393   {
00394     if((i>=L)||(i<0)) 
00395       { cerr << "DynString::operator[]\n"; raise(SIGQUIT); }
00396 \end{verbatim}\normalsize 


\subsection{Friends And Related Function Documentation}
\index{DynString@{Dyn\-String}!AddDSDelim@{AddDSDelim}}
\index{AddDSDelim@{AddDSDelim}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Add\-DSDelim (char {\em delim})\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l1}




Definition at line 45 of file dynstring.C.\footnotesize\begin{verbatim}00046   { DynString::Delimiter[(uint) delim] = 1; }
00047 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!DSprintf@{DSprintf}}
\index{DSprintf@{DSprintf}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int DSprintf (Dyn\-String \& {\em ds}, const char $\ast$ {\em cntl}, ...)\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l7}


\index{DynString@{Dyn\-String}!GetDSDelim@{GetDSDelim}}
\index{GetDSDelim@{GetDSDelim}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String Get\-DSDelim ()\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l3}




Definition at line 51 of file dynstring.C.

Referenced by Read\-Line().\footnotesize\begin{verbatim}00052   {
00053     DynString delim;
00054     delim.DestResizeToFit(256);
00055     int j=0;
00056     for(uint i=0; i<256; ++i)
00057       {
00058         if(DynString::Delimiter[i])
00059           {
00060             delim.innards[j] = (char) i;
00061             ++j;
00062           }
00063       }
00064 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!IntToDS@{IntToDS}}
\index{IntToDS@{IntToDS}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String Int\-To\-DS (int {\em i})\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l4}




Definition at line 351 of file dynstring.C.\footnotesize\begin{verbatim}00352   {
00353     char s[100]; s[0] = '\0';
00354     sprintf(s, "%i", i);
00355     DynString ds(s);
00356     return ds;
00357 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!RemDSDelim@{RemDSDelim}}
\index{RemDSDelim@{RemDSDelim}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Rem\-DSDelim (char {\em delim})\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l2}




Definition at line 47 of file dynstring.C.\footnotesize\begin{verbatim}00048   { DynString::Delimiter[(uint) delim] = 0; }
00049 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!Reproduce@{Reproduce}}
\index{Reproduce@{Reproduce}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String Reproduce (char {\em c}, int {\em n})\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l5}




Definition at line 745 of file dynstring.C.

Referenced by Pad().\footnotesize\begin{verbatim}00746   {
00747     DynString str;
00748     if(!str.DestResizeToFit(n)) return str;
00749     for(int i=0; i<n; ++i) str.innards[i] = c;
00750     str.innards[n] = '\0';
00751     str.L = n;
00752     return str;
00753 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!SetDSDelim@{SetDSDelim}}
\index{SetDSDelim@{SetDSDelim}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void Set\-DSDelim (const Dyn\-String \& {\em delim})\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l0}




Definition at line 34 of file dynstring.C.

Referenced by Read\-Line().\footnotesize\begin{verbatim}00035   {
00036     uint j;
00037     for(int i=0; i<256; ++i) DynString::Delimiter[i] = 0;
00038     for(int i=0; i<delim.L; ++i)
00039       {
00040         j = (uint) delim.innards[i];
00041         DynString::Delimiter[j] = 1;
00042       }
00043 \end{verbatim}\normalsize 
\index{DynString@{Dyn\-String}!operator+@{operator+}}
\index{operator+@{operator+}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String operator+ (Dyn\-String {\em x}, const Dyn\-String \& {\em y})\hspace{0.3cm}{\tt  [friend]}}\label{class_DynString_l6}




Definition at line 162 of file dynstring.h.\footnotesize\begin{verbatim}00163   { return x+=y; }
00164 \end{verbatim}\normalsize 


\subsection{Member Data Documentation}
\index{DynString@{Dyn\-String}!Bad@{Bad}}
\index{Bad@{Bad}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Dyn\-String::Bad = 0\hspace{0.3cm}{\tt  [static]}}\label{class_DynString_p0}




Definition at line 16 of file dynstring.C.\index{DynString@{Dyn\-String}!BlockSize@{BlockSize}}
\index{BlockSize@{BlockSize}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const int Dyn\-String::Block\-Size = 32\hspace{0.3cm}{\tt  [static]}}\label{class_DynString_p1}




Definition at line 11 of file dynstring.C.\index{DynString@{Dyn\-String}!Delimiter@{Delimiter}}
\index{Delimiter@{Delimiter}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::Delimiter[256]\hspace{0.3cm}{\tt  [static]}}\label{class_DynString_p2}


{\bf Initial value:}\footnotesize\begin{verbatim} 

{ 
  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
}\end{verbatim}\normalsize 


Definition at line 20 of file dynstring.C.\index{DynString@{Dyn\-String}!Empty@{Empty}}
\index{Empty@{Empty}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Dyn\-String Dyn\-String::Empty = ""\hspace{0.3cm}{\tt  [static]}}\label{class_DynString_p3}




Definition at line 18 of file dynstring.C.\index{DynString@{Dyn\-String}!L@{L}}
\index{L@{L}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::L\hspace{0.3cm}{\tt  [private]}}\label{class_DynString_o2}




Definition at line 243 of file dynstring.h.\index{DynString@{Dyn\-String}!N@{N}}
\index{N@{N}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int Dyn\-String::N\hspace{0.3cm}{\tt  [private]}}\label{class_DynString_o1}




Definition at line 240 of file dynstring.h.\index{DynString@{Dyn\-String}!innards@{innards}}
\index{innards@{innards}!DynString@{Dyn\-String}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ Dyn\-String::innards\hspace{0.3cm}{\tt  [private]}}\label{class_DynString_o0}




Definition at line 238 of file dynstring.h.

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