\section{ABit\-Set  Class Reference}
\label{class_ABitSet}\index{ABitSet@{ABit\-Set}}
{\tt \#include $<$abitset.h$>$}

\subsection*{Public Methods}
\begin{CompactItemize}
\item 
{\bf ABit\-Set} ()
\item 
{\bf ABit\-Set} ({\bf uint})
\item 
{\bf ABit\-Set} (const ABit\-Set \&)
\item 
{\bf $\sim$ABit\-Set} ()
\item 
const ABit\-Set\& {\bf operator=} (const ABit\-Set \&)
\item 
bool {\bf Resize} ({\bf uint} n)
\item 
bool {\bf Is\-All\-Set} () const
\item 
bool {\bf Is\-All\-Clear} () const
\item 
bool {\bf Is\-Empty} () const
\item 
bool {\bf operator[$\,$]} ({\bf uint}) const
\item 
bool {\bf Is\-Set} ({\bf uint} i) const
\item 
void {\bf Set} ({\bf uint})
\item 
void {\bf Clear} ({\bf uint})
\item 
void {\bf Invert} ({\bf uint})
\item 
bool {\bf In} ({\bf uint} i) const
\item 
void {\bf Add} ({\bf uint} i)
\item 
void {\bf Remove} ({\bf uint} i)
\item 
void {\bf Set} ({\bf uint}, {\bf uint})
\item 
void {\bf Clear} ({\bf uint}, {\bf uint})
\item 
void {\bf Invert} ({\bf uint}, {\bf uint})
\item 
void {\bf Set\-All} ()
\item 
void {\bf Clear\-All} ()
\item 
void {\bf Invert\-All} ()
\item 
const ABit\-Set\& {\bf operator$|$=} (const ABit\-Set \&)
\item 
const ABit\-Set\& {\bf operator \&=} (const ABit\-Set \&)
\item 
const ABit\-Set\& {\bf operator$^\wedge$=} (const ABit\-Set \&)
\item 
const ABit\-Set\& {\bf operator-=} (const ABit\-Set \&)
\item 
ABit\-Set {\bf operator$|$} (const ABit\-Set \&) const
\item 
ABit\-Set {\bf operator \&} (const ABit\-Set \&) const
\item 
ABit\-Set {\bf operator$^\wedge$} (const ABit\-Set \&) const
\item 
ABit\-Set {\bf operator-} (const ABit\-Set \&) const
\item 
bool {\bf Increment} ()
\item 
bool {\bf Decrement} ()
\item 
int {\bf Compare} (const ABit\-Set \&) const
\item 
int {\bf Number} () const
\item 
int {\bf Count} () const
\item 
{\bf MAKECOMPARISONS\_\-WITH\_\-COMPARE} (ABit\-Set)
\end{CompactItemize}
\subsection*{Static Public Methods}
\begin{CompactItemize}
\item 
{\bf uint} {\bf Default\-Size} ({\bf uint} s)
\item 
{\bf uint} {\bf Default\-Size} ()
\end{CompactItemize}
\subsection*{Static Protected Attributes}
\begin{CompactItemize}
\item 
{\bf uint} {\bf default\_\-size} = 256
\end{CompactItemize}
\subsection*{Private Attributes}
\begin{CompactItemize}
\item 
{\bf uint} {\bf num}
\item 
char$\ast$ {\bf data}
\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
ostream\& {\bf operator$<$$<$} (ostream \&os, const ABit\-Set \&)
\item 
ostream\& {\bf Output\-Binary} (ostream \&, const ABit\-Set \&)
\item 
istream\& {\bf Input\-Binary} (istream \&, ABit\-Set \&)
\item 
ostream\& {\bf operator$<$=} (ostream \&os, const ABit\-Set \&bs)
\item 
istream\& {\bf operator$>$=} (istream \&is, ABit\-Set \&bs)
\end{CompactItemize}


\subsection{Constructor \& Destructor Documentation}
\index{ABitSet@{ABit\-Set}!ABitSet@{ABitSet}}
\index{ABitSet@{ABitSet}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set::ABit\-Set ()}\label{class_ABitSet_a0}




Definition at line 28 of file abitset.C.\footnotesize\begin{verbatim}00029 : num(default_size)
00030 {
00031         data = new char[b2c1(num)];
00032         ClearAll();
00033 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!ABitSet@{ABitSet}}
\index{ABitSet@{ABitSet}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set::ABit\-Set ({\bf uint} {\em n})}\label{class_ABitSet_a1}




Definition at line 35 of file abitset.C.\footnotesize\begin{verbatim}00036 : num(n)
00037 {
00038         if (num<1)
00039                 num = 1;
00040         data = new char[b2c1(num)];
00041         ClearAll();
00042 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!ABitSet@{ABitSet}}
\index{ABitSet@{ABitSet}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set::ABit\-Set (const ABit\-Set \& {\em abs})}\label{class_ABitSet_a2}




Definition at line 44 of file abitset.C.\footnotesize\begin{verbatim}00045 : num(abs.num)
00046 {
00047         const uint x=b2c1(num);
00048         data = new char[x];
00049         memcpy(data, abs.data, x);
00050 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!~ABitSet@{$\sim$ABitSet}}
\index{~ABitSet@{$\sim$ABitSet}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set::$\sim$ABit\-Set ()}\label{class_ABitSet_a3}




Definition at line 52 of file abitset.C.\footnotesize\begin{verbatim}00053 {
00054         delete[] data;
00055         data = 0;
00056         num = 0;
00057 \end{verbatim}\normalsize 


\subsection{Member Function Documentation}
\index{ABitSet@{ABit\-Set}!Add@{Add}}
\index{Add@{Add}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Add ({\bf uint} {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{class_ABitSet_a15}




Definition at line 75 of file abitset.h.\footnotesize\begin{verbatim}00076                                 { Set(i); }
00077 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Clear@{Clear}}
\index{Clear@{Clear}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Clear ({\bf uint} {\em i}, {\bf uint} {\em j})}\label{class_ABitSet_a18}




Definition at line 163 of file abitset.C.\footnotesize\begin{verbatim}00164 {
00165         if (i>j)
00166                 util_swap(i,j);
00167         if ( j>=num )
00168                 return;
00169 
00170         for (uint k=i; k<=j; ++k)
00171                 Clear(k);
00172 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Clear@{Clear}}
\index{Clear@{Clear}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Clear ({\bf uint} {\em i})}\label{class_ABitSet_a12}




Definition at line 133 of file abitset.C.

Referenced by Clear(), KAdj\-Mat::Disconnect(), and Remove().\footnotesize\begin{verbatim}00134 {
00135         if ( i>=num )
00136                 return;
00137 
00138         data[b2c0(i)] &= ~b2i(i);
00139 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!ClearAll@{ClearAll}}
\index{ClearAll@{ClearAll}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Clear\-All ()}\label{class_ABitSet_a21}




Definition at line 215 of file abitset.C.

Referenced by ABit\-Set(), bf\_\-iterator::reset(), and df\_\-iterator::reset().\footnotesize\begin{verbatim}00216 {
00217         memset(data, 0, b2c1(num));
00218 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Compare@{Compare}}
\index{Compare@{Compare}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int ABit\-Set::Compare (const ABit\-Set \& {\em abs}) const}\label{class_ABitSet_a33}




Definition at line 350 of file abitset.C.\footnotesize\begin{verbatim}00351 {
00352         if (num != abs.num)
00353                 return abs.num - num;
00354 
00355         uint    n = b2c1(num);
00356 
00357         for (uint i=0; i<n; ++i)
00358         {
00359                 if (data[i] != abs.data[i])
00360                         return abs.data[i] - data[i];
00361         }
00362 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Count@{Count}}
\index{Count@{Count}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int ABit\-Set::Count () const}\label{class_ABitSet_a35}




Definition at line 229 of file abitset.C.\footnotesize\begin{verbatim}00230 {
00231         uint    n = b2c1(num);
00232         int     tot = 0;
00233         for (uint i=0; i<n; ++i)
00234                 tot += bit_count(data[i]);
00235         return tot;
00236 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Decrement@{Decrement}}
\index{Decrement@{Decrement}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Decrement ()}\label{class_ABitSet_a32}




Definition at line 330 of file abitset.C.\footnotesize\begin{verbatim}00331 {
00332         uint    n = b2c1(num);
00333         bool            carry_flag = 1;
00334         uint    i = 0;
00335 
00336         while ( carry_flag && (i<n) )
00337         {
00338                 carry_flag = 0;
00339                 int     z = data[i];
00340                 ++z;
00341                 if (z & 256)
00342                         carry_flag = 1;
00343                 data[i] = z & 255;
00344                 ++i;
00345         }
00346 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!DefaultSize@{DefaultSize}}
\index{DefaultSize@{DefaultSize}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf uint} ABit\-Set::Default\-Size ()\hspace{0.3cm}{\tt  [static]}}\label{class_ABitSet_d1}




Definition at line 109 of file abitset.C.\footnotesize\begin{verbatim}00110 {
00111         return default_size;
00112 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!DefaultSize@{DefaultSize}}
\index{DefaultSize@{DefaultSize}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf uint} ABit\-Set::Default\-Size ({\bf uint} {\em s})\hspace{0.3cm}{\tt  [static]}}\label{class_ABitSet_d0}




Definition at line 99 of file abitset.C.\footnotesize\begin{verbatim}00100 {
00101         uint    o = default_size;
00102         if (s<1)
00103                 s = 1;
00104         default_size = s;
00105         return o;
00106 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!In@{In}}
\index{In@{In}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::In ({\bf uint} {\em i}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_ABitSet_a14}




Definition at line 73 of file abitset.h.\footnotesize\begin{verbatim}00074                                 { return ($\ast$this)[i]; }
00075 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Increment@{Increment}}
\index{Increment@{Increment}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Increment ()}\label{class_ABitSet_a31}




Definition at line 310 of file abitset.C.\footnotesize\begin{verbatim}00311 {
00312         uint    n = b2c1(num);
00313         bool            carry_flag = 1;
00314         uint    i = 0;
00315 
00316         while ( carry_flag && (i<n) )
00317         {
00318                 carry_flag = 0;
00319                 int     z = data[i];
00320                 ++z;
00321                 if (z & 256)
00322                         carry_flag = 1;
00323                 data[i] = z & 255;
00324                 ++i;
00325         }
00326 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Invert@{Invert}}
\index{Invert@{Invert}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Invert ({\bf uint} {\em i}, {\bf uint} {\em j})}\label{class_ABitSet_a19}




Definition at line 175 of file abitset.C.\footnotesize\begin{verbatim}00176 {
00177         if (i>j)
00178                 util_swap(i,j);
00179         if ( j>=num )
00180                 return;
00181 
00182         for (uint k=i; k<=j; ++k)
00183                 Invert(k);
00184 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Invert@{Invert}}
\index{Invert@{Invert}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Invert ({\bf uint} {\em i})}\label{class_ABitSet_a13}




Definition at line 142 of file abitset.C.

Referenced by Invert().\footnotesize\begin{verbatim}00143 {
00144         if ( i>=num )
00145                 return;
00146 
00147         data[b2c0(i)] ^= b2i(i);
00148 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!InvertAll@{InvertAll}}
\index{InvertAll@{InvertAll}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Invert\-All ()}\label{class_ABitSet_a22}




Definition at line 221 of file abitset.C.\footnotesize\begin{verbatim}00222 {
00223         uint    n = b2c1(num);
00224         for (uint i=0; i<n; ++i)
00225                 data[i] ^= ~0;
00226 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!IsAllClear@{IsAllClear}}
\index{IsAllClear@{IsAllClear}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Is\-All\-Clear () const}\label{class_ABitSet_a7}




Definition at line 198 of file abitset.C.

Referenced by Is\-Empty().\footnotesize\begin{verbatim}00199 {
00200         uint    n = b2c1(num);
00201         if (n>1)
00202                 for (uint i=0; i<n-1; ++i)
00203                         if (data[i] != 0)
00204                                 return 0;
00205         return (data[n-1] & all_set[num%8]) == '\x00';
00206 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!IsAllSet@{IsAllSet}}
\index{IsAllSet@{IsAllSet}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Is\-All\-Set () const}\label{class_ABitSet_a6}




Definition at line 187 of file abitset.C.

Referenced by bf\_\-iterator::operator++(), and df\_\-iterator::operator++().\footnotesize\begin{verbatim}00188 {
00189         uint    n = b2c1(num);
00190         if (n>1)
00191                 for (uint i=0; i<n-1; ++i)
00192                         if (data[i] != '\xFF')
00193                                 return 0;
00194         return (data[n-1] & all_set[num%8]) == all_set[num%8];
00195 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!IsEmpty@{IsEmpty}}
\index{IsEmpty@{IsEmpty}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Is\-Empty () const\hspace{0.3cm}{\tt  [inline]}}\label{class_ABitSet_a8}




Definition at line 62 of file abitset.h.\footnotesize\begin{verbatim}00063                         { return IsAllClear(); }
00064 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!IsSet@{IsSet}}
\index{IsSet@{IsSet}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Is\-Set ({\bf uint} {\em i}) const\hspace{0.3cm}{\tt  [inline]}}\label{class_ABitSet_a10}




Definition at line 66 of file abitset.h.

Referenced by sd\-Graph::Trav\-Lists(), bf\_\-iterator::operator++(), and df\_\-iterator::operator++().\footnotesize\begin{verbatim}00067                                 { return ($\ast$this)[i]; }
00068 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!MAKECOMPARISONS_WITH_COMPARE@{MAKECOMPARISONS\_\-WITH\_\-COMPARE}}
\index{MAKECOMPARISONS_WITH_COMPARE@{MAKECOMPARISONS\_\-WITH\_\-COMPARE}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set::MAKECOMPARISONS\_\-WITH\_\-COMPARE (ABit\-Set)}\label{class_ABitSet_a36}


\index{ABitSet@{ABit\-Set}!Number@{Number}}
\index{Number@{Number}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int ABit\-Set::Number () const\hspace{0.3cm}{\tt  [inline]}}\label{class_ABitSet_a34}




Definition at line 102 of file abitset.h.\footnotesize\begin{verbatim}00103                         { return num; }
00104 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Remove@{Remove}}
\index{Remove@{Remove}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Remove ({\bf uint} {\em i})\hspace{0.3cm}{\tt  [inline]}}\label{class_ABitSet_a16}




Definition at line 77 of file abitset.h.\footnotesize\begin{verbatim}00078                                 { Clear(i); }
00079 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Resize@{Resize}}
\index{Resize@{Resize}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::Resize ({\bf uint} {\em n})}\label{class_ABitSet_a5}




Definition at line 80 of file abitset.C.\footnotesize\begin{verbatim}00081 {
00082         if (n<1)
00083                 n = 1;
00084         if (n==num)
00085                 return 1;
00086 
00087         int     m = util_min(n,num);
00088         char*   newd = new char[n];
00089         if (!newd)
00090                 return 0;
00091 
00092         memcpy (newd, data, m);
00093         delete[] data;
00094         data = newd;
00095         return 1;
00096 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Set@{Set}}
\index{Set@{Set}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Set ({\bf uint} {\em i}, {\bf uint} {\em j})}\label{class_ABitSet_a17}




Definition at line 151 of file abitset.C.\footnotesize\begin{verbatim}00152 {
00153         if (i>j)
00154                 util_swap(i,j);
00155         if ( j>=num )
00156                 j=num-1;
00157 
00158         for (uint k=i; k<=j; ++k)
00159                 Set(k);
00160 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!Set@{Set}}
\index{Set@{Set}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Set ({\bf uint} {\em i})}\label{class_ABitSet_a11}




Definition at line 124 of file abitset.C.

Referenced by Add(), KAdj\-Mat::Connect(), Set(), bf\_\-iterator::operator++(), df\_\-iterator::operator++(), bf\_\-iterator::reset(), and df\_\-iterator::reset().\footnotesize\begin{verbatim}00125 {
00126         if ( i>=num )
00127                 return;
00128 
00129         data[b2c0(i)] |= b2i(i);
00130 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!SetAll@{SetAll}}
\index{SetAll@{SetAll}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ABit\-Set::Set\-All ()}\label{class_ABitSet_a20}




Definition at line 209 of file abitset.C.\footnotesize\begin{verbatim}00210 {
00211         memset(data, ~0, b2c1(num));
00212 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator &@{operator \&}}
\index{operator &@{operator \&}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set ABit\-Set::operator \& (const ABit\-Set \& {\em abs}) const}\label{class_ABitSet_a28}




Definition at line 289 of file abitset.C.\footnotesize\begin{verbatim}00290 {
00291         ABitSet res(*this);
00292         return res &= abs;
00293 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator &=@{operator \&=}}
\index{operator &=@{operator \&=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const ABit\-Set \& ABit\-Set::operator \&= (const ABit\-Set \& {\em abs})}\label{class_ABitSet_a24}




Definition at line 250 of file abitset.C.\footnotesize\begin{verbatim}00251 {
00252         uint    n = b2c1(util_min(num, abs.num));
00253 
00254         for (uint i=0; i<n; ++i)
00255                 data[i] &= abs.data[i];
00256 
00257         return *this;
00258 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator-@{operator-}}
\index{operator-@{operator-}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set ABit\-Set::operator- (const ABit\-Set \& {\em abs}) const}\label{class_ABitSet_a30}




Definition at line 296 of file abitset.C.\footnotesize\begin{verbatim}00297 {
00298         ABitSet res(*this);
00299         return res -= abs;
00300 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator-=@{operator-=}}
\index{operator-=@{operator-=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const ABit\-Set \& ABit\-Set::operator-= (const ABit\-Set \& {\em abs})}\label{class_ABitSet_a26}




Definition at line 261 of file abitset.C.\footnotesize\begin{verbatim}00262 {
00263         uint    n = b2c1(util_min(num, abs.num));
00264         for (uint i=0; i<n; ++i)
00265                 data[i] &= ~(abs.data[i]);
00266 
00267         return *this;
00268 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator=@{operator=}}
\index{operator=@{operator=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const ABit\-Set \& ABit\-Set::operator= (const ABit\-Set \& {\em abs})}\label{class_ABitSet_a4}




Definition at line 60 of file abitset.C.\footnotesize\begin{verbatim}00061 {
00062         if (this == &abs)
00063                 return *this;
00064 
00065         const uint x=b2c1(abs.num);
00066 
00067         if (b2c1(num) < x)
00068         {
00069                 delete[] data;
00070                 data = new char[x];
00071         }
00072 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator[]@{operator[]}}
\index{operator[]@{operator[]}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool ABit\-Set::operator[$\,$] ({\bf uint} {\em i}) const}\label{class_ABitSet_a9}




Definition at line 115 of file abitset.C.\footnotesize\begin{verbatim}00116 {
00117         if ( i>=num )
00118                 return 0;
00119 
00120         return data[b2c0(i)] & b2i(i);
00121 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator^@{operator$^\wedge$}}
\index{operator^@{operator$^\wedge$}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set ABit\-Set::operator$^\wedge$ (const ABit\-Set \& {\em abs}) const}\label{class_ABitSet_a29}




Definition at line 303 of file abitset.C.\footnotesize\begin{verbatim}00304 {
00305         ABitSet res(*this);
00306         return res ^= abs;
00307 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator^=@{operator$^\wedge$=}}
\index{operator^=@{operator$^\wedge$=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const ABit\-Set \& ABit\-Set::operator$^\wedge$= (const ABit\-Set \& {\em abs})}\label{class_ABitSet_a25}




Definition at line 271 of file abitset.C.\footnotesize\begin{verbatim}00272 {
00273         uint    n = b2c1(util_min(num, abs.num));
00274 
00275         for (uint i=0; i<n; ++i)
00276                 data[i] ^= abs.data[i];
00277 
00278         return *this;
00279 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator\texttt{"|}@{operator\texttt{"|}}}
\index{operator\texttt{"|}@{operator\texttt{"|}}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ABit\-Set ABit\-Set::operator$|$ (const ABit\-Set \& {\em abs}) const}\label{class_ABitSet_a27}




Definition at line 282 of file abitset.C.\footnotesize\begin{verbatim}00283 {
00284         ABitSet res(*this);
00285         return res |= abs;
00286 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator\texttt{"|}=@{operator\texttt{"|}=}}
\index{operator\texttt{"|}=@{operator\texttt{"|}=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const ABit\-Set \& ABit\-Set::operator$|$= (const ABit\-Set \& {\em abs})}\label{class_ABitSet_a23}




Definition at line 239 of file abitset.C.\footnotesize\begin{verbatim}00240 {
00241         uint    n = b2c1(util_min(num, abs.num));
00242 
00243         for (uint i=0; i<n; ++i)
00244                 data[i] |= abs.data[i];
00245 
00246         return *this;
00247 \end{verbatim}\normalsize 


\subsection{Friends And Related Function Documentation}
\index{ABitSet@{ABit\-Set}!InputBinary@{InputBinary}}
\index{InputBinary@{InputBinary}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}istream\& Input\-Binary (istream \& {\em is}, ABit\-Set \& {\em bs})\hspace{0.3cm}{\tt  [friend]}}\label{class_ABitSet_l2}




Definition at line 448 of file abitset.C.

Referenced by Input\-Binary(), and operator$>$=().\footnotesize\begin{verbatim}00449 {
00450         if (!is)
00451                 return is;
00452 
00453         uint    n;
00454         InputBinary(is,n);
00455 
00456         delete[] bs.data;
00457         bs.num = n;
00458         bs.data = new char[b2c1(n)];
00459         if (!bs.data)
00460                 raise(SIGQUIT);
00461 
00462         is.read(bs.data, b2c1(bs.num));
00463         return is;
00464 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!OutputBinary@{OutputBinary}}
\index{OutputBinary@{OutputBinary}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& Output\-Binary (ostream \& {\em os}, const ABit\-Set \& {\em bs})\hspace{0.3cm}{\tt  [friend]}}\label{class_ABitSet_l1}




Definition at line 436 of file abitset.C.

Referenced by Output\-Binary(), and operator$<$=().\footnotesize\begin{verbatim}00437 {
00438         if (!os)
00439                 return os;
00440         OutputBinary(os,bs.num);
00441         if (!os)
00442                 return os;
00443         os.write(bs.data, b2c1(bs.num));
00444         return os;
00445 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator<<@{operator$<$$<$}}
\index{operator<<@{operator$<$$<$}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream\& operator$<$$<$ (ostream \& {\em os}, const ABit\-Set \& {\em abs})\hspace{0.3cm}{\tt  [friend]}}\label{class_ABitSet_l0}




Definition at line 367 of file abitset.C.\footnotesize\begin{verbatim}00368 {
00369         os << '<';
00370         for (uint i=0; i<abs.num; ++i)
00371                 os << (abs[i] ? '1' : '0');
00372         os << '>';
00373         return os;
00374 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator<=@{operator$<$=}}
\index{operator<=@{operator$<$=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}ostream \& operator$<$= (ostream \& {\em os}, const ABit\-Set \& {\em bs})\hspace{0.3cm}{\tt  [friend]}}\label{class_ABitSet_l3}




Definition at line 113 of file abitset.h.\footnotesize\begin{verbatim}00114                 { return OutputBinary(os,bs); }
00115 \end{verbatim}\normalsize 
\index{ABitSet@{ABit\-Set}!operator>=@{operator$>$=}}
\index{operator>=@{operator$>$=}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}istream \& operator$>$= (istream \& {\em is}, ABit\-Set \& {\em bs})\hspace{0.3cm}{\tt  [friend]}}\label{class_ABitSet_l4}




Definition at line 115 of file abitset.h.\footnotesize\begin{verbatim}00116                 { return InputBinary(is,bs); }
00117 \end{verbatim}\normalsize 


\subsection{Member Data Documentation}
\index{ABitSet@{ABit\-Set}!data@{data}}
\index{data@{data}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char $\ast$ ABit\-Set::data\hspace{0.3cm}{\tt  [private]}}\label{class_ABitSet_o1}




Definition at line 22 of file abitset.h.\index{ABitSet@{ABit\-Set}!default_size@{default\_\-size}}
\index{default_size@{default\_\-size}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf uint} ABit\-Set::default\_\-size = 256\hspace{0.3cm}{\tt  [static, protected]}}\label{class_ABitSet_q0}




Definition at line 9 of file abitset.C.\index{ABitSet@{ABit\-Set}!num@{num}}
\index{num@{num}!ABitSet@{ABit\-Set}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf uint} ABit\-Set::num\hspace{0.3cm}{\tt  [private]}}\label{class_ABitSet_o0}




Definition at line 21 of file abitset.h.

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