SWBuf Class Reference

#include <swbuf.h>

Collaboration diagram for SWBuf:
Collaboration graph
[legend]

List of all members.

Public Member Functions

void append (wchar_t wch)
void append (char ch)
void append (const SWBuf &str, long max=-1)
void append (const char *str, long max=-1)
void appendFormatted (const char *format,...)
const char * c_str () const
char & charAt (unsigned long pos)
int compare (const char *other) const
int compare (const SWBuf &other) const
bool endsWith (const char *postfix) const
bool endsWith (const SWBuf &postfix) const
char getFillByte ()
char * getRawData ()
long indexOf (const SWBuf &needle) const
void insert (unsigned long pos, char c)
void insert (unsigned long pos, const SWBuf &str, unsigned long start=0, signed long max=-1)
void insert (unsigned long pos, const char *str, unsigned long start=0, signed long max=-1)
unsigned long length () const
 operator const char * () const
bool operator!= (const char *other) const
bool operator!= (const SWBuf &other) const
SWBuf operator+ (char ch) const
SWBuf operator+ (const SWBuf &other) const
SWBufoperator+= (char ch)
SWBufoperator+= (const char *str)
SWBufoperator-- (int)
SWBufoperator-= (unsigned long len)
bool operator< (const char *other) const
bool operator< (const SWBuf &other) const
SWBufoperator<< (unsigned long n)
bool operator<= (const char *other) const
bool operator<= (const SWBuf &other) const
SWBufoperator= (const SWBuf &other)
SWBufoperator= (const char *newVal)
bool operator== (const char *other) const
bool operator== (const SWBuf &other) const
bool operator> (const char *other) const
bool operator> (const SWBuf &other) const
bool operator>= (const char *other) const
bool operator>= (const SWBuf &other) const
SWBufoperator>> (unsigned long n)
char & operator[] (int pos)
char & operator[] (unsigned int pos)
char & operator[] (long pos)
char & operator[] (unsigned long pos)
SWBufreplaceBytes (const char *targets, char newByte)
void resize (unsigned long len)
void set (const char *newVal)
void set (const SWBuf &newVal)
void setFillByte (char ch)
SWBufsetFormatted (const char *format,...)
void setSize (unsigned long len)
void size (unsigned long newSize)
unsigned long size () const
bool startsWith (const char *prefix) const
bool startsWith (const SWBuf &prefix) const
const char * stripPrefix (char separator, bool endOfStringAsSeparator=false)
 SWBuf (const SWBuf &other, unsigned long initSize=0)
 SWBuf (char initVal, unsigned long initSize=0)
 SWBuf (const char *initVal, unsigned long initSize=0)
 SWBuf ()
SWBuftrim ()
SWBuftrimEnd ()
SWBuftrimStart ()
 ~SWBuf ()

Private Member Functions

void assureMore (size_t pastEnd)
void assureSize (size_t checkSize)
void init (size_t initSize)

Private Attributes

unsigned long allocSize
char * buf
char * end
char * endAlloc
char fillByte

Static Private Attributes

static char junkBuf [JUNKBUFSIZE]
static char * nullStr = (char *)""

Detailed Description

This class is used as a transport and utility for data buffers.

Warning:
This class does not perform pointer validity checks (for speed reasons). Therefore, never try to pass an invalid string (const char* 0) as an argument- it will crash your program. You need to perform the checks yourself!

Definition at line 44 of file swbuf.h.


Constructor & Destructor Documentation

SWBuf::SWBuf (  )  [inline]

Definition at line 88 of file swbuf.h.

00088                    {
00089         init(0);
00090     }

SWBuf::SWBuf ( const char *  initVal,
unsigned long  initSize = 0 
)

SWBuf Constructor - Creates an SWBuf initialized to a value from a const char *

Definition at line 38 of file swbuf.cpp.

00038                                                         {
00039     init(initSize);
00040     if (initVal)
00041         set(initVal);
00042 }

SWBuf::SWBuf ( char  initVal,
unsigned long  initSize = 0 
)

SWBuf Constructor - Creates an SWBuf initialized to a value from a char

Definition at line 59 of file swbuf.cpp.

00059                                                  {
00060     init(initSize+1);
00061     *buf = initVal;
00062     end = buf+1;
00063     *end = 0;
00064 }

SWBuf::SWBuf ( const SWBuf other,
unsigned long  initSize = 0 
)

SWBuf Constructor - Creates an SWBuf initialized to a value from another SWBuf

Definition at line 49 of file swbuf.cpp.

00049                                                        {
00050     init(initSize);
00051     set(other);
00052 }

SWBuf::~SWBuf (  )  [inline]

Definition at line 117 of file swbuf.h.

00117                     {
00118         if ((buf) && (buf != nullStr))
00119             free(buf);
00120     }


Member Function Documentation

void SWBuf::append ( wchar_t  wch  )  [inline]

SWBuf::append - appends a wide charachter value to the current value of this SWBuf If the allocated memory is not enough, it will be resized accordingly. NOTE: This is dangerous, as wchar_t is currently different sizes on different platforms (stupid windoze; stupid c++ spec for not mandating 4byte).

Parameters:
ch Append this.

Definition at line 263 of file swbuf.h.

00263                                     {
00264         assureMore(sizeof(wchar_t)*2);
00265         for (unsigned int i = 0; i < sizeof(wchar_t); i++) *end++ = ((char *)&wch)[i];
00266         for (unsigned int i = 0; i < sizeof(wchar_t); i++) end[i] = 0;
00267     }

void SWBuf::append ( char  ch  )  [inline]

SWBuf::append - appends a value to the current value of this SWBuf If the allocated memory is not enough, it will be resized accordingly.

Parameters:
ch Append this.

Definition at line 250 of file swbuf.h.

00250                                 {
00251         assureMore(1);
00252         *end++ = ch;
00253         *end = 0;
00254     }

void SWBuf::append ( const SWBuf str,
long  max = -1 
) [inline]

SWBuf::append - appends a value to the current value of this SWBuf If the allocated memory is not enough, it will be resized accordingly.

Parameters:
str Append this.
max Append only max chars.

Definition at line 243 of file swbuf.h.

00243 { append(str.c_str(), max); }

void SWBuf::append ( const char *  str,
long  max = -1 
)

SWBuf::append - appends a value to the current value of this SWBuf. If the allocated memory is not enough, it will be resized accordingly.

Parameters:
str Append this.
max Append only max chars.

Definition at line 100 of file swbuf.cpp.

00100                                             {
00101 //  if (!str) //A null string was passed
00102 //      return;
00103     if (max < 0)
00104         max = strlen(str);
00105     assureMore(max+1);
00106     for (;((max)&&(*str));max--)
00107         *end++ = *str++;
00108     *end = 0;
00109 }

void SWBuf::appendFormatted ( const char *  format,
  ... 
)

SWBuf::appendFormatted - appends formatted strings to the current value of this SWBuf.

Warning:
This function can only write at most JUNKBUFSIZE to the string per call.
This function is not very fast. For loops with many iterations you might consider replacing it by other calls. Example:
 SWBuf buf.appendFormatted("<%s>", stringVal); 
should be replaced by:
 buf.append("<"); buf.append(stringVal); buf.append(">"); 
This will produce much faster results.
Parameters:
format The format string. Same syntax as printf, for example.
... Add all arguments here.

Definition at line 127 of file swbuf.cpp.

00127                                                    {
00128     va_list argptr;
00129 
00130     va_start(argptr, format);
00131 #ifdef NO_VSNPRINTF
00132     int len = vsprintf(junkBuf, format, argptr)+1;
00133 #else
00134     int len = vsnprintf(0, 0, format, argptr)+1;
00135 #endif
00136     va_end(argptr);
00137     assureMore(len);
00138     va_start(argptr, format);
00139     end += vsprintf(end, format, argptr);
00140     va_end(argptr);
00141 }

void SWBuf::assureMore ( size_t  pastEnd  )  [inline, private]

Definition at line 53 of file swbuf.h.

00053                                            {
00054         if (size_t(endAlloc-end) < pastEnd) {
00055             assureSize(allocSize + pastEnd);
00056         }
00057     }

void SWBuf::assureSize ( size_t  checkSize  )  [inline, private]

Definition at line 59 of file swbuf.h.

00059                                              {
00060         if (checkSize > allocSize) {
00061             long size = (end - buf);
00062             checkSize += 128;
00063             buf = (char *)((allocSize) ? realloc(buf, checkSize) : malloc(checkSize));
00064             allocSize = checkSize;
00065             end = (buf + size);
00066             *end = 0;
00067             endAlloc = buf + allocSize - 1;
00068         }
00069     }

const char* SWBuf::c_str (  )  const [inline]
Returns:
a pointer to the buffer content (null-terminated string)

Definition at line 140 of file swbuf.h.

00140 { return buf; }

char& SWBuf::charAt ( unsigned long  pos  )  [inline]
Parameters:
pos The position of the requested character.
Returns:
The character at the specified position

Definition at line 146 of file swbuf.h.

00146 { return ((pos <= (unsigned long)(end - buf)) ? buf[pos] : ((*junkBuf=0),*junkBuf)); }

int SWBuf::compare ( const char *  other  )  const [inline]

Definition at line 442 of file swbuf.h.

00442 { return (other?strcmp(c_str(), other):-1); }

int SWBuf::compare ( const SWBuf other  )  const [inline]

Definition at line 423 of file swbuf.h.

00423 { return strcmp(c_str(), other.c_str()); }

bool SWBuf::endsWith ( const char *  postfix  )  const [inline]
Returns:
returns true if this buffer ends with the specified postfix

Definition at line 439 of file swbuf.h.

00439 { unsigned int psize = strlen(postfix); return (size() >= psize)?!strncmp(end-psize, postfix, psize):false; }

bool SWBuf::endsWith ( const SWBuf postfix  )  const [inline]
Returns:
returns true if this buffer ends with the specified postfix

Definition at line 416 of file swbuf.h.

00416 { return (size() >= postfix.size())?!strncmp(end-postfix.size(), postfix.c_str(), postfix.size()):false; }

char SWBuf::getFillByte (  )  [inline]

SWBuf::getFillByte - Get the fillByte character

Returns:
The character used for filling memory.
See also:
setFillByte.

Definition at line 135 of file swbuf.h.

00135 { return fillByte; }

char* SWBuf::getRawData (  )  [inline]

SWBuf::getRawData

Warning:
be careful! Probably setSize needs to be called in conjunction before and maybe after
Returns:
Pointer to the allocated memory of the SWBuf.

Definition at line 322 of file swbuf.h.

00322 { return buf; }

long SWBuf::indexOf ( const SWBuf needle  )  const [inline]
Returns:
returns the index of a substring if it is found in this buffer; otherwise, returns < 0

Definition at line 421 of file swbuf.h.

00421 { const char *ch = strstr(buf, needle.c_str()); return (ch) ? ch - buf : -1; }

void SWBuf::init ( size_t  initSize  )  [inline, private]

Definition at line 71 of file swbuf.h.

00071                                       {
00072         fillByte = ' ';
00073         allocSize = 0;
00074         buf = nullStr;
00075         end = buf;
00076         endAlloc = buf;
00077         if (initSize)
00078             assureSize(initSize);
00079     }

void SWBuf::insert ( unsigned long  pos,
char  c 
) [inline]

SWBuf::insert - inserts the given character at position into this string

Parameters:
pos The position where to insert. pos=0 inserts at the beginning, pos=1 after the first char, etc. Using pos=length() is the same as calling append(s)
c Insert this.

Definition at line 312 of file swbuf.h.

00312                                                   {
00313         insert(pos, SWBuf(c));
00314     }

void SWBuf::insert ( unsigned long  pos,
const SWBuf str,
unsigned long  start = 0,
signed long  max = -1 
) [inline]

SWBuf::insert - inserts the given string at position into this string

Parameters:
pos The position where to insert. pos=0 inserts at the beginning, pos=1 after the first char, etc. Using pos=length() is the same as calling append(s)
str string to be inserted
start start from this position in the string to be inserted
max Insert only max chars.

Definition at line 303 of file swbuf.h.

00303                                                                                                            {
00304         insert(pos, str.c_str(), start, max);
00305     };

void SWBuf::insert ( unsigned long  pos,
const char *  str,
unsigned long  start = 0,
signed long  max = -1 
)

SWBuf::insert - inserts the given string at position into this string

Parameters:
pos The position where to insert. pos=0 inserts at the beginning, pos=1 after the first char, etc. Using pos=length() is the same as calling append(s)
str string to be inserted
start start from this position in the string to be inserted
max Insert only max chars.

Definition at line 143 of file swbuf.cpp.

00143                                                                                            {
00144 //  if (!str) //A null string was passed
00145 //      return;
00146 
00147     str += start;
00148     int len = (max > -1) ? max : strlen(str);
00149 
00150     if (!len || (pos > length())) //nothing to do, return
00151         return;
00152     
00153     // pos==length(), so we can call append in this case
00154     if (pos == length()) { //append is more efficient
00155         append(str, max);
00156         return;
00157     }
00158     
00159     assureMore( len );
00160     
00161     memmove(buf + pos + len, buf + pos, (end - buf) - pos); //make a gap of "len" bytes
00162     memcpy(buf+pos, str, len);
00163     
00164     end += len;
00165     *end = 0;
00166 }

unsigned long SWBuf::length (  )  const [inline]
Returns:
size() and length() return only the number of characters of the string.

Definition at line 164 of file swbuf.h.

00164 { return end - buf; }

SWBuf::operator const char * (  )  const [inline]

Definition at line 324 of file swbuf.h.

00324 { return c_str(); }

bool SWBuf::operator!= ( const char *  other  )  const [inline]

Definition at line 444 of file swbuf.h.

00444 { return compare(other) != 0; }

bool SWBuf::operator!= ( const SWBuf other  )  const [inline]

Definition at line 425 of file swbuf.h.

00425 { return compare(other) != 0; }

SWBuf SWBuf::operator+ ( char  ch  )  const [inline]

Concatenate a byte to the end of this buffer

Definition at line 367 of file swbuf.h.

00367 { return (*this) + SWBuf(ch); }

SWBuf SWBuf::operator+ ( const SWBuf other  )  const [inline]

Concatenate another buffer to the end of this buffer

Definition at line 358 of file swbuf.h.

00358                                                       {
00359         SWBuf retVal = buf;
00360         retVal += other;
00361         return retVal;
00362     }

SWBuf& SWBuf::operator+= ( char  ch  )  [inline]

Definition at line 332 of file swbuf.h.

00332 { append(ch); return *this; }

SWBuf& SWBuf::operator+= ( const char *  str  )  [inline]

Definition at line 331 of file swbuf.h.

00331 { append(str); return *this; }

SWBuf& SWBuf::operator-- ( int   )  [inline]

Decrease the buffer size, discarding the last character

Definition at line 343 of file swbuf.h.

00343 { operator -=(1); return *this; }

SWBuf& SWBuf::operator-= ( unsigned long  len  )  [inline]

Decrease the buffer size, discarding the last characters

Parameters:
len how many bytes to decrease the buffer size

Definition at line 338 of file swbuf.h.

00338 { setSize(length()-len); return *this; }

bool SWBuf::operator< ( const char *  other  )  const [inline]

Definition at line 446 of file swbuf.h.

00446 { return other && compare(other) < 0; }

bool SWBuf::operator< ( const SWBuf other  )  const [inline]

Definition at line 427 of file swbuf.h.

00427 { return compare(other) < 0; }

SWBuf& SWBuf::operator<< ( unsigned long  n  )  [inline]

Shift the buffer to the left, discarding the first bytes, decreasing the buffer size

Definition at line 348 of file swbuf.h.

00348 { if (n && length()) { n = (n<=length())?n:(length()-1); memmove(buf, buf+n, length()-n); (*this)-=n; } return *this; }

bool SWBuf::operator<= ( const char *  other  )  const [inline]

Definition at line 447 of file swbuf.h.

00447 { return other && compare(other) <= 0; }

bool SWBuf::operator<= ( const SWBuf other  )  const [inline]

Definition at line 428 of file swbuf.h.

00428 { return compare(other) <= 0; }

SWBuf& SWBuf::operator= ( const SWBuf other  )  [inline]

Definition at line 330 of file swbuf.h.

00330 { set(other); return *this; }

SWBuf& SWBuf::operator= ( const char *  newVal  )  [inline]

Definition at line 329 of file swbuf.h.

00329 { set(newVal); return *this; }

bool SWBuf::operator== ( const char *  other  )  const [inline]

Definition at line 443 of file swbuf.h.

00443 { return compare(other) == 0; }

bool SWBuf::operator== ( const SWBuf other  )  const [inline]

Definition at line 424 of file swbuf.h.

00424 { return compare(other) == 0; }

bool SWBuf::operator> ( const char *  other  )  const [inline]

Definition at line 445 of file swbuf.h.

00445 { return other && compare(other) > 0; }

bool SWBuf::operator> ( const SWBuf other  )  const [inline]

Definition at line 426 of file swbuf.h.

00426 { return compare(other) > 0; }

bool SWBuf::operator>= ( const char *  other  )  const [inline]

Definition at line 448 of file swbuf.h.

00448 { return other && compare(other) >= 0; }

bool SWBuf::operator>= ( const SWBuf other  )  const [inline]

Definition at line 429 of file swbuf.h.

00429 { return compare(other) >= 0; }

SWBuf& SWBuf::operator>> ( unsigned long  n  )  [inline]

Shift the buffer to the right, increasing the buffer size

Definition at line 353 of file swbuf.h.

00353 { setSize(length()+n); memmove(buf+n, buf, length()-n); return *this; }

char& SWBuf::operator[] ( int  pos  )  [inline]

Definition at line 328 of file swbuf.h.

00328 { return charAt((unsigned long)pos); }

char& SWBuf::operator[] ( unsigned int  pos  )  [inline]

Definition at line 327 of file swbuf.h.

00327 { return charAt((unsigned long)pos); }

char& SWBuf::operator[] ( long  pos  )  [inline]

Definition at line 326 of file swbuf.h.

00326 { return charAt((unsigned long)pos); }

char& SWBuf::operator[] ( unsigned long  pos  )  [inline]

Definition at line 325 of file swbuf.h.

00325 { return charAt(pos); }

SWBuf& SWBuf::replaceBytes ( const char *  targets,
char  newByte 
) [inline]

Replace with a new byte value all occurances in this buffer of any byte value specified in a set

Parameters:
targets a set of bytes, any of which will be replaced
newByte value to use as replacement.

Example: replaceBytes("abc", 'z'); // replaces all occurances of 'a', 'b', and 'c' with 'z'

Definition at line 406 of file swbuf.h.

00406 { for (unsigned int i = 0; (i < size()); i++) { if (strchr(targets, buf[i])) buf[i] = newByte; } return *this; }

void SWBuf::resize ( unsigned long  len  )  [inline]

SWBuf::resize - Resize this buffer to a specific length.

Parameters:
len The new size of the buffer. One byte for the null will be added.

Definition at line 227 of file swbuf.h.

00227 { setSize(len); }

void SWBuf::set ( const char *  newVal  )  [inline]

SWBuf::set - sets this buf to a new value. If the allocated memory is bigger than the new string, it will NOT be resized.

Parameters:
newVal the value to set this buffer to.

Definition at line 185 of file swbuf.h.

00185                                         {
00186         if (newVal) {
00187             unsigned long len = strlen(newVal) + 1;
00188             assureSize(len);
00189             memcpy(buf, newVal, len);
00190             end = buf + (len - 1);
00191         }
00192         else {
00193             assureSize(1);
00194             end = buf;
00195             *end = 0;
00196         }
00197     }

void SWBuf::set ( const SWBuf newVal  )  [inline]

SWBuf::set - sets this buf to a new value If the allocated memory is bigger than the new string, it will NOT be resized.

Parameters:
newVal the value to set this buffer to.

Definition at line 171 of file swbuf.h.

00171                                          {
00172         unsigned long len = newVal.length() + 1;
00173         assureSize(len);
00174 //      const char *n = newVal.c_str();
00175 //      for (end = buf;len;len--) *end++ = *n++;
00176         memcpy(buf, newVal.c_str(), len);
00177         end = buf + (len - 1);
00178     }

void SWBuf::setFillByte ( char  ch  )  [inline]

SWBuf::setFillByte - Set the fillByte character

Parameters:
ch This character is used when the SWBuf is (re)sized. The memory will be filled with this character.
See also:
setSize()
resize()

Definition at line 128 of file swbuf.h.

00128 { fillByte = ch; }

SWBuf & SWBuf::setFormatted ( const char *  format,
  ... 
)

SWBuf::setFormatted - sets this buf to a formatted string. If the allocated memory is bigger than the new string, it will NOT be resized.

Warning:
This function can only write at most JUNKBUFSIZE to the string per call.
This function is not very fast. For loops with many iterations you might consider replacing it by other calls. Example:
 SWBuf buf.setFormatted("<%s>", stringVal); 
should be replaced by:
 buf.set("<"); buf.append(stringVal); buf.append(">"); 
This will produce much faster results.
Parameters:
format The format string. Same syntax as printf, for example.
... Add all arguments here.

Definition at line 79 of file swbuf.cpp.

00079                                                   {
00080     va_list argptr;
00081 
00082     va_start(argptr, format);
00083 #ifdef NO_VSNPRINTF
00084     int len = vsprintf(junkBuf, format, argptr)+1;
00085 #else
00086     int len = vsnprintf(0, 0, format, argptr)+1;
00087 #endif
00088     va_end(argptr);
00089     assureSize(len);
00090     va_start(argptr, format);
00091     end = vsprintf(buf, format, argptr) + buf;
00092     va_end(argptr);
00093     return *this;
00094 }

void SWBuf::setSize ( unsigned long  len  ) 

SWBuf::setSize - Size this buffer to a specific length.

Parameters:
len The new size of the buffer. One byte for the null will be added.

Definition at line 114 of file swbuf.cpp.

00114                                      {
00115     assureSize(len+1);
00116     if ((unsigned)(end - buf) < len)
00117         memset(end, fillByte, len - (end-buf));
00118     end = buf + len;
00119     *end = 0;
00120 }

void SWBuf::size ( unsigned long  newSize  )  [inline]

set's the size of the buffer. This is a quick inline method which checks for changes before actually calling setSize().

Parameters:
newSize new size of the buffer

Definition at line 159 of file swbuf.h.

00159 { if (end - buf - newSize) setSize(newSize); }

unsigned long SWBuf::size (  )  const [inline]
Returns:
size() and length() return only the number of characters of the string. Add one for the following null and one for each char to be appended!

Definition at line 152 of file swbuf.h.

00152 { return length(); }

bool SWBuf::startsWith ( const char *  prefix  )  const [inline]
Returns:
returns true if this buffer starts with the specified prefix

Definition at line 434 of file swbuf.h.

00434 { return !strncmp(c_str(), prefix, strlen(prefix)); }

bool SWBuf::startsWith ( const SWBuf prefix  )  const [inline]
Returns:
returns true if this buffer starts with the specified prefix

Definition at line 411 of file swbuf.h.

00411 { return !strncmp(c_str(), prefix.c_str(), prefix.size()); }

const char* SWBuf::stripPrefix ( char  separator,
bool  endOfStringAsSeparator = false 
) [inline]

Strip a prefix from this buffer up to a separator byte. Returns the prefix and modifies this buffer, shifting left to remove prefix

Parameters:
separator to use (e.g. ':')
endOfStringAsSeparator - also count end of string as separator. this is useful for tokenizing entire string like: x|y|z if true it will also include 'z'.
Returns:
prefix if separator character found; otherwise, null and leaves buffer unmodified

Definition at line 396 of file swbuf.h.

00396 { const char *m = strchr(buf, separator); if (!m && endOfStringAsSeparator) { if (*buf) { operator >>(1); *buf=0; end = buf; return buf + 1;} else return buf; } if (m) { int len = m-buf; char *hold = new char[len]; memcpy(hold, buf, len); *this << (len+1); memcpy(end+1, hold, len); delete [] hold; end[len+1] = 0; } return (m) ? end+1 : 0; }  // safe.  we know we don't actually realloc and shrink buffer when shifting, so we can place our return val at end.

SWBuf& SWBuf::trim (  )  [inline]

Trim whitespace from the start and end of this buffer, shifting left and decreasing size as necessary

Definition at line 382 of file swbuf.h.

00382 { trimStart(); return trimEnd(); }

SWBuf& SWBuf::trimEnd (  )  [inline]

Trim whitespace from the end of this buffer, decreasing the size as necessary

Definition at line 377 of file swbuf.h.

00377 { while (size() && (strchr("\t\r\n ", *(end-1)))) setSize(size()-1); return *this; }

SWBuf& SWBuf::trimStart (  )  [inline]

Trim whitespace from the start of this buffer, shifting the buffer left as necessary

Definition at line 372 of file swbuf.h.

00372 { while (size() && (strchr("\t\r\n ", *(buf)))) *this << 1; return *this; }


Member Data Documentation

unsigned long SWBuf::allocSize [private]

Definition at line 49 of file swbuf.h.

char* SWBuf::buf [private]

Definition at line 45 of file swbuf.h.

char* SWBuf::end [private]

Definition at line 46 of file swbuf.h.

char* SWBuf::endAlloc [private]

Definition at line 47 of file swbuf.h.

char SWBuf::fillByte [private]

Definition at line 48 of file swbuf.h.

char SWBuf::junkBuf [static, private]

Definition at line 51 of file swbuf.h.

SWORD_NAMESPACE_START char * SWBuf::nullStr = (char *)"" [static, private]

Definition at line 50 of file swbuf.h.


The documentation for this class was generated from the following files:

Generated on 18 Mar 2013 for The SWORD Project by  doxygen 1.6.1