swbuf.h

Go to the documentation of this file.

/******************************************************************************
 *
 * swbuf.h -    class SWBuf: a rich buffer / string class providing optimized
 *      implementations of many basic string operations
 *
 * $Id: swbuf.h 3786 2020-08-30 11:35:14Z scribe $
 *
 * Copyright 2003-2013 CrossWire Bible Society (http://www.crosswire.org)
 *  CrossWire Bible Society
 *  P. O. Box 2528
 *  Tempe, AZ  85280-2528
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation version 2.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

#ifndef SWBUF_H
#define SWBUF_H

#include <defs.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#ifdef __BORLANDC__
#include <mem.h>
#endif

SWORD_NAMESPACE_START


#define JUNKBUFSIZE 65534

class SWDLLEXPORT SWBuf {

private:
    char *buf;
    char *end;
    char *endAlloc;
    char fillByte;
    unsigned long allocSize;

    inline void assureMore(size_t pastEnd) {
        if (size_t(endAlloc-end) < pastEnd) {
            assureSize(allocSize + pastEnd);
        }
    }

    inline void assureSize(size_t checkSize) {
        if (checkSize > allocSize) {
            long size = (end - buf);
            checkSize += 128;
            buf = (char *)((allocSize) ? realloc(buf, checkSize) : malloc(checkSize));
            allocSize = checkSize;
            end = (buf + size);
            *end = 0;
            endAlloc = buf + allocSize - 1;
        }
    }

    inline void init(size_t initSize) {
        fillByte = ' ';
        allocSize = 0;
        buf = nullStr;
        end = buf;
        endAlloc = buf;
        if (initSize)
            assureSize(initSize);
    }


public:

    static char *nullStr;

    /******************************************************************************
    * SWBuf Constructor - Creates an empty SWBuf object
    *
    */
    inline SWBuf() {
        init(0);
    }

    /******************************************************************************
    * SWBuf Constructor - Creates an empty SWBuf object or an SWBuf initialized
    *       to a value from a const char *
    *
    */
    inline SWBuf(const char *initVal, unsigned long initSize = 0) {
        init(initSize);
        if (initVal)
            set(initVal, initSize);
    }

    /******************************************************************************
    * SWBuf Constructor - Creates an SWBuf initialized
    *       to a value from another SWBuf
    *
    */
    inline SWBuf(const SWBuf &other, unsigned long initSize = 0) {
        init(initSize);
        set(other);
    }

    /******************************************************************************
    * SWBuf Constructor - Creates an SWBuf initialized
    *       to a value from a char
    *
    */
    inline SWBuf(char initVal, unsigned long initSize = 0) {
        init(initSize+1);
        *buf = initVal;
        end = buf+1;
        *end = 0;
    }
//  SWBuf(unsigned long initSize);


    /******************************************************************************
    * SWBuf Destructor - Cleans up instance of SWBuf
    */
    inline ~SWBuf() {
        if ((buf) && (buf != nullStr))
            free(buf);
    }

    inline void setFillByte(char ch) { fillByte = ch; }

    inline char getFillByte() { return fillByte; }

    inline const char *c_str() const{ return buf; }

    // fastest guarded impl.  If we reference out of bounds, we return our 
    inline char &charAtGuarded(unsigned long pos) { return ((pos <= (unsigned long)(endAlloc - buf)) ? buf[pos] : (*endAlloc)); }
    // unguarded impl. This is obviously much faster and is likely why std::string specifies references out of bounds have undefined
    // behavior.  This is the default impl for operator []
    inline char &charAt(unsigned long pos) { return *(buf + pos); }
    inline const char &charAt(unsigned long pos) const { return *(buf + pos); }

// these have all proven to be slower implementations
//  inline char &charAt(unsigned long pos) { return buf[pos]; }
//  inline char &charAtGuarded(unsigned long pos) { return pos <= (unsigned long)end - (unsigned long)buf ? buf[pos] : *nullStr; }
//  inline char &charAtGuarded(unsigned long pos) { return pos <= length() ? buf[pos] : *nullStr; }
//  inline char &charAtGuarded(unsigned long pos) { assureSize(pos); return buf[pos]; }
//  inline char &charAtGuarded(unsigned long pos) { return pos < allocSize ? buf[pos] : *nullStr; }
//  inline char &charAtGuarded(unsigned long pos) { return buf + pos <= end ? buf[pos] : *nullStr; }
//  inline char &charAtGuarded(unsigned long pos) { return buf[pos < allocSize ? pos : allocSize - 1]; }


    inline unsigned long size() const { return length(); }

    inline void size(unsigned long newSize) { if (end - buf - newSize) setSize(newSize); }

    inline unsigned long length() const { return end - buf; }

    inline void set(const SWBuf &newVal) {
        unsigned long len = newVal.allocSize;
        assureSize(len);
        memcpy(buf, newVal.c_str(), len);
        end = buf + (newVal.length());
    }

    inline void set(const char *newVal, unsigned long maxSize = 0) {
        if (newVal) {
            unsigned long len = strlen(newVal) + 1;
            if (maxSize && maxSize < (len-1)) len = maxSize + 1;
            assureSize(len);
            memcpy(buf, newVal, len);
            end = buf + (len - 1);
        }
        else {
            assureSize(1);
            end = buf;
        }
        *end = 0;
    }

    SWBuf &setFormatted(const char *format, ...);
    SWBuf &setFormattedVA(const char *format, va_list argptr);

    inline void setSize(unsigned long len) {
        assureSize(len+1);
        if ((unsigned)(end - buf) < len)
            memset(end, fillByte, (size_t)len - (end-buf));
        end = buf + len;
        *end = 0;
    }
    inline void resize(unsigned long len) { setSize(len); }

    inline SWBuf &append(const char *str, long max = -1) {
    //  if (!str) //A null string was passed
    //      return;
        if (max < 0)
            max = strlen(str);
        assureMore(max+1);
        for (;((max)&&(*str));max--)
            *end++ = *str++;
        *end = 0;
        return *this;
    }

    inline SWBuf &append(const SWBuf &str, long max = -1) { return append(str.c_str(), max); }

    inline SWBuf &append(char ch) {
        assureMore(1);
        *end++ = ch;
        *end = 0;
        return *this;
    }
    inline SWBuf &append(const unsigned char ch) {
        assureMore(1);
        *end++ = ch;
        *end = 0;
        return *this;
    }

    inline SWBuf &append(wchar_t wch) {
        assureMore(sizeof(wchar_t)*2);
        for (unsigned int i = 0; i < sizeof(wchar_t); i++) *end++ = ((char *)&wch)[i];
        for (unsigned int i = 0; i < sizeof(wchar_t); i++) end[i] = 0;
        return *this;
    }

    SWBuf &appendFormatted(const char *format, ...);
    
    void insert(unsigned long pos, const char* str, unsigned long start = 0, signed long max = -1);

    inline void insert(unsigned long pos, const SWBuf &str, unsigned long start = 0, signed long max = -1) {
        insert(pos, str.c_str(), start, max);
    };

    inline void insert(unsigned long pos, char c) {
        insert(pos, SWBuf(c));
    }

    inline char *getRawData() { return buf; }

    inline operator const char *() const { return c_str(); }
    inline char &operator[](unsigned long pos) { return charAt(pos); }
    inline char &operator[](long pos) { return charAt((unsigned long)pos); }
    inline char &operator[](unsigned int pos) { return charAt((unsigned long)pos); }
    inline char &operator[](int pos) { return charAt((unsigned long)pos); }
    inline const char &operator[](unsigned long pos) const { return charAt(pos); }
    inline const char &operator[](long pos) const { return charAt((unsigned long)pos); }
    inline const char &operator[](unsigned int pos) const { return charAt((unsigned long)pos); }
    inline const char &operator[](int pos) const { return charAt((unsigned long)pos); }
    inline SWBuf &operator =(const char *newVal) { set(newVal); return *this; }
    inline SWBuf &operator =(const SWBuf &other) { set(other); return *this; }
    inline SWBuf &operator +=(const char *str) { return append(str); }
    inline SWBuf &operator +=(char ch) { return append(ch); }

    inline SWBuf &operator -=(unsigned long len) { setSize(length()-len); return *this; }

    inline SWBuf &operator --(int) { operator -=(1); return *this; }

    inline SWBuf &operator <<(unsigned long n) { if (n && length()) { n = (n<=length())?n:(length()-1); memmove(buf, buf+n, length()-n); (*this)-=n; } return *this; }

    inline SWBuf &operator >>(unsigned long n) { setSize(length()+n); memmove(buf+n, buf, length()-n); return *this; }

    inline SWBuf operator +(const SWBuf &other) const {
        SWBuf retVal = buf;
        retVal += other;
        return retVal;
    }

    inline SWBuf operator +(char ch) const { return (*this) + SWBuf(ch); }

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

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

    inline SWBuf &trim() { trimStart(); return trimEnd(); }


    inline const char *stripPrefix(char separator, bool endOfStringAsSeparator = false) { 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 = (int)(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.

    // this could be nicer, like replacing a contiguous series of target bytes with single replacement; offering replacement const char *
    inline SWBuf &replaceBytes(const char *targets, char newByte) {
        for (unsigned int i = 0; (i < size()); i++) {
            if (strchr(targets, buf[i])) {
                if (newByte) buf[i] = newByte;
                // delete byte
                else {
                    if (i < (size()-1)) {
                        memmove(buf+i, buf+i+1, length()-i-1);
                    }
                    (*this)-=1;
                }
            }
        }
        return *this;
    }

    inline bool startsWith(const SWBuf &prefix) const { return !strncmp(c_str(), prefix.c_str(), prefix.size()); }
    SWBuf &toUpper();
    SWBuf &toLower();

    inline bool endsWith(const SWBuf &postfix) const { return (size() >= postfix.size())?!strncmp(end-postfix.size(), postfix.c_str(), postfix.size()):false; }

    inline long indexOf(const SWBuf &needle) const { const char *ch = strstr(buf, needle.c_str()); return (ch) ? ch - buf : -1; }
    
    inline int compare(const SWBuf &other) const { return strcmp(c_str(), other.c_str()); }
    inline bool operator ==(const SWBuf &other) const { return compare(other) == 0; }
    inline bool operator !=(const SWBuf &other) const { return compare(other) != 0; }
    inline bool operator > (const SWBuf &other) const { return compare(other) > 0; }
    inline bool operator < (const SWBuf &other) const { return compare(other) < 0; }
    inline bool operator <=(const SWBuf &other) const { return compare(other) <= 0; }
    inline bool operator >=(const SWBuf &other) const { return compare(other) >= 0; }

    inline bool startsWith(const char *prefix) const { return !strncmp(c_str(), prefix, strlen(prefix)); }

    inline bool endsWith(const char *postfix) const { unsigned int psize = (unsigned int)strlen(postfix); return (size() >= psize)?!strncmp(end-psize, postfix, psize):false; }

    // be sure we've been given a valid pointer to compare.  If not, we return !=; specifically less-than, for lack of better options
    inline int compare(const char *other) const { return (other?strcmp(c_str(), other):-1); }
    inline bool operator ==(const char *other) const { return compare(other) == 0; }
    inline bool operator !=(const char *other) const { return compare(other) != 0; }
    inline bool operator > (const char *other) const { return other && compare(other) > 0; }
    inline bool operator < (const char *other) const { return other && compare(other) < 0; }
    inline bool operator <=(const char *other) const { return other && compare(other) <= 0; }
    inline bool operator >=(const char *other) const { return other && compare(other) >= 0; }
};



SWORD_NAMESPACE_END
#endif