Changeset 973 for cpp/frams/util


Ignore:
Timestamp:
07/03/20 00:37:13 (4 years ago)
Author:
Maciej Komosinski
Message:

Increased SString and std::string compatibility: introduced length(), size(), and capacity(), and removed legacy methods that have std::string equivalents

Location:
cpp/frams/util
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • cpp/frams/util/extvalue.cpp

    r940 r973  
    326326                {
    327327                        SString tmp = getString();
    328                         if (tmp.len() > 30) tmp = tmp.substr(0, 30) + "...";
     328                        if (tmp.length() > 30) tmp = tmp.substr(0, 30) + "...";
    329329                        if (type == TString) tmp = SString("\"") + tmp + SString("\"");
    330330                        logPrintf("ExtValue", "getObjectTarget", LOG_WARN, "%s object expected, %s found", classname, tmp.c_str());
    … …  
    614614                        return;
    615615                case TDouble:
    616                         setDouble(double(getInt())*src.getDouble());
     616                        setDouble(double(getInt()) * src.getDouble());
    617617                        return;
    618618                default:;
    … …  
    790790        //            ^-cur     ^-next
    791791        //            ^^^^^^^^^^___sub
    792         const char* begin = fmt.c_str(), *end = begin + fmt.len(), *curr = begin;
     792        const char* begin = fmt.c_str(), *end = begin + fmt.length(), *curr = begin;
    793793        int type = 0;
    794794
    … …  
    14011401        err->message = args[0].getString();
    14021402        if (err->message.startsWith(TO_STRING_PREFIX.c_str()))
    1403                 err->message = err->message.substr(TO_STRING_PREFIX.len());
     1403                err->message = err->message.substr(TO_STRING_PREFIX.length());
    14041404        *ret = makeDynamicObject(err);
    14051405}

  • cpp/frams/util/sstring-simple.cpp

    r970 r973  
    88void SString::initEmpty()
    99{
    10         txt = NULL; used = 0; size = 0;
     10        txt = NULL; used = 0; allocated = 0;
    1111}
    1212
    … …  
    1818SString::~SString()
    1919{
    20         resize(0);
     20        reallocate(0);
    2121}
    2222
    … …  
    3636SString::SString(SString&& from)
    3737{
    38         txt = from.txt; size = from.size; used = from.used;
    39         from.txt = NULL; from.size = 0; from.used = 0;
     38        txt = from.txt; allocated = from.allocated; used = from.used;
     39        from.txt = NULL; from.allocated = 0; from.used = 0;
    4040}
    4141
    … …  
    4646}
    4747
    48 void SString::resize(int newsize)
    49 {
    50         if (newsize == size) return;
     48void SString::reallocate(int newsize)
     49{
     50        if (newsize == allocated) return;
    5151        txt = (char*)realloc(txt, newsize);
    52         size = newsize;
    53 }
    54 
    55 void SString::ensureSize(int needed)
    56 {
    57         if (size > needed) return;
    58         resize((size > 0) ? (needed + needed / 2 + 1) : (needed + 1));
     52        allocated = newsize;
     53}
     54
     55void SString::ensureAllocated(int needed)
     56{
     57        if (allocated > needed) return;
     58        reallocate((allocated > 0) ? (needed + needed / 2 + 1) : (needed + 1));
    5959}
    6060
    6161char *SString::directWrite(int ensuresize)
    6262{
    63         ensureSize(ensuresize);
     63        ensureAllocated(ensuresize);
    6464        appending = used;
    6565        return txt;
    … …  
    6868char *SString::directAppend(int maxappend)
    6969{
    70         ensureSize(used + maxappend);
     70        ensureAllocated(used + maxappend);
    7171        appending = used;
    7272        return txt + appending;
    … …  
    7878        else txt[newlength] = 0;
    7979        used = newlength;
    80         assert(used < size);
     80        assert(used < allocated);
    8181}
    8282
    … …  
    8686        else txt[appending + newappend] = 0;
    8787        used = appending + newappend;
    88         assert(used < size);
     88        assert(used < allocated);
    8989}
    9090
    … …  
    102102{
    103103        if (!n) return;
    104         ensureSize(used + n);
     104        ensureAllocated(used + n);
    105105        memmove(txt + used, t, n);
    106106        used += n;
    … …  
    110110void SString::operator+=(const SString&s)
    111111{
    112         append(s.c_str(), s.len());
     112        append(s.c_str(), s.length());
    113113}
    114114
    … …  
    116116{
    117117        SString ret;
    118         ret.reserve(len() + s.len());
     118        ret.reserve(length() + s.length());
    119119        ret = *this;
    120120        ret += s;
    … …  
    130130        if (chlen)
    131131        {
    132                 ensureSize(chlen);
     132                ensureAllocated(chlen);
    133133                memmove(txt, ch, chlen);
    134134                txt[chlen] = 0;
    … …  
    153153{
    154154        if (&s == this) return;
    155         copyFrom(s.c_str(), s.len());
     155        copyFrom(s.c_str(), s.length());
    156156}
    157157
    158158///////////////////////////////////////
    159159
    160 SString SString::substr(int begin, int length) const
    161 {
    162         if (begin < 0) { length += begin; begin = 0; }
    163         if (length >= (len() - begin)) length = len() - begin;
    164         if (length <= 0) return SString();
    165         if (length == len()) return *this;
    166         return SString((*this)(begin), length);
     160SString SString::substr(int begin, int numchars) const
     161{
     162        if (begin < 0) { numchars += begin; begin = 0; }
     163        if (numchars >= (length() - begin)) numchars = length() - begin;
     164        if (numchars <= 0) return SString();
     165        if (numchars == length()) return *this;
     166        return SString((*this)(begin), numchars);
    167167}
    168168
    … …  
    172172{
    173173        if (this == &s) return true;
    174         if (len() != s.len()) return false;
     174        if (length() != s.length()) return false;
    175175        return strcmp(getPtr(), s.getPtr()) == 0;
    176176}
    … …  
    198198bool SString::getNextToken(int& pos, SString &token, char separator) const
    199199{
    200         if (pos >= len()) { token = 0; return false; }
     200        if (pos >= length()) { token = 0; return false; }
    201201        int p1 = pos, p2;
    202202        const char *t1 = getPtr() + pos;
    203203        const char *t2 = strchr(t1, separator);
    204         if (t2) pos = (p2 = (t2 - getPtr())) + 1; else p2 = pos = len();
     204        if (t2) pos = (p2 = (t2 - getPtr())) + 1; else p2 = pos = length();
    205205        strncpy(token.directWrite(p2 - p1), t1, p2 - p1);
    206206        token.endWrite(p2 - p1);
    … …  
    254254                char* p = ret.directWrite(size);
    255255                assert(p != NULL);
    256                 size = ret.directMaxLen() + 1;
     256                size = ret.capacity() + 1;
    257257                /* Try to print in the allocated space. */
    258258                va_start(ap, format);

  • cpp/frams/util/sstring-simple.h

    r955 r973  
    1414private:
    1515        char *txt;      ///< string buffer or NULL for empty string
    16         int size;       ///< allocated memory (including \0)
     16        int allocated;       ///< allocated memory (including \0)
    1717        int used;       ///< string length
    1818        int appending;  ///< append mode, changes can occur after character # 'appending'
    … …  
    2020        void initEmpty();
    2121        void copyFrom(SString &from); ///< copy from SString
    22         void resize(int newsize);
    23         void ensureSize(int needed);
     22        void reallocate(int newsize);
     23        void ensureAllocated(int needed);
    2424        const char* getPtr() const { return txt ? txt : ""; }
    2525
    … …  
    3434
    3535        void copyFrom(const char* ch, int chlen = -1); ///< copy string, length of -1 == unknown
    36        
    37         void* operator new(size_t s, void* mem){ return mem; }
     36
     37        void* operator new(size_t s, void* mem) { return mem; }
    3838#ifdef _MSC_VER
    39                 void operator delete(void* mem, void* t) {}
     39        void operator delete(void* mem, void* t) {}
    4040#endif
    41         void* operator new(size_t s){ return malloc(sizeof(SString)); }
     41        void* operator new(size_t s) { return malloc(sizeof(SString)); }
    4242        void operator delete(void* mem) { free(mem); }
    4343
    44         int len() const { return used; } ///< get string length
     44        int length() const { return used; } ///< get string length
     45        int size() const { return length(); } ///< get string length
    4546        void shrink(); ///< free unnecessary buffer
    46         void reserve(int needed) { ensureSize(needed); } ///< like in std::string
     47        void reserve(int cap) { ensureAllocated(cap + 1); } ///< like in std::string
    4748
    4849        /// after this call, you can modify sstring directly.
    … …  
    8788        void endAppend(int appendlength = -1);
    8889
    89         void memoryHint(int howbig) { ensureSize(howbig); }
    90         int directMaxLen() { return size - 1; } ///< when called after directWrite: max number of characters allowed (can be more than requested)
     90        int capacity() { return (allocated > 0) ? (allocated - 1) : allocated; } ///< std::string.capacity()
    9191
    9292        /// find a character in SString.

  • cpp/frams/util/sstring.cpp

    r970 r973  
    163163}
    164164
    165 void SString::memoryHint(int howbig)
    166 {
    167         detachCopy(howbig);
    168 }
    169 
    170165void SString::detachEmpty(int ensuresize)
    171166{
    … …  
    201196char *SString::directWrite(int ensuresize)
    202197{
    203         if (ensuresize < 0) ensuresize = len();
     198        if (ensuresize < 0) ensuresize = length();
    204199        REF_LOCK;
    205200        detachCopy(ensuresize);
    … …  
    259254void SString::operator+=(const SString&s)
    260255{
    261         append(s.c_str(), s.len());
     256        append(s.c_str(), s.length());
    262257}
    263258
    … …  
    298293///////////////////////////////////////
    299294
    300 SString SString::substr(int begin, int length) const
    301 {
    302         if (begin < 0) { length += begin; begin = 0; }
    303         if (length >= (len() - begin)) length = len() - begin;
    304         if (length <= 0) return SString();
    305         if (length == len()) return *this;
    306         return SString((*this)(begin), length);
     295SString SString::substr(int begin, int numchars) const
     296{
     297        if (begin < 0) { numchars += begin; begin = 0; }
     298        if (numchars >= (length() - begin)) numchars = length() - begin;
     299        if (numchars <= 0) return SString();
     300        if (numchars == length()) return *this;
     301        return SString((*this)(begin), numchars);
    307302}
    308303
    … …  
    337332bool SString::getNextToken(int& pos, SString &token, char separator) const
    338333{
    339         if (pos >= len()) { token = 0; return false; }
     334        if (pos >= length()) { token = 0; return false; }
    340335        int p1 = pos, p2;
    341336        const char *t1 = buf->txt + pos;
    342337        const char *t2 = strchr(t1, separator);
    343         if (t2) pos = (p2 = (t2 - buf->txt)) + 1; else p2 = pos = len();
     338        if (t2) pos = (p2 = (t2 - buf->txt)) + 1; else p2 = pos = length();
    344339        strncpy(token.directWrite(p2 - p1), t1, p2 - p1);
    345340        token.endWrite(p2 - p1);
    … …  
    401396                char* p = ret.directWrite(size);
    402397                assert(p != NULL);
    403                 size = ret.directMaxLen() + 1;
     398                size = ret.capacity() + 1;
    404399                /* Try to print in the allocated space. */
    405400                va_start(ap, format);

  • cpp/frams/util/sstring.h

    r955 r973  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
    … …  
    8585        void operator delete(void* mem) { free(mem); }
    8686
    87         int len() const { return buf->used; } ///< get string length
     87        int size() const { return buf->used; } ///< get string length
     88        int length() const { return buf->used; } ///< get string length
    8889        void shrink(); ///< free unnecessary buffer
    89         void reserve(int needed) { ensureSize(needed); } ///< like in std::string
     90        void reserve(int needed) { detachCopy(needed); } ///< like in std::string
    9091
    9192        /// after this call, you can modify sstring directly.
    … …  
    129130        /// t.endAppend(bytecount);</CODE>
    130131        void endAppend(int appendlength = -1);
    131         /// argument is the amount of memory, that will be probably used
    132         /// by this string instance. string can use this value
    133         /// to optimize memory allocation (bigger chunks will be allocated).
    134         void memoryHint(int howbig);
    135         int directMaxLen() { return buf->size; } ///< when called after directWrite: max number of characters allowed (can be more than requested)
     132        int capacity() { return buf->size; } ///< std::string.capacity()
    136133
    137134        /// find a character in SString.

  • cpp/frams/util/sstringutils.cpp

    r904 r973  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
    … …  
    7979                else
    8080                {
    81                         if (tmp.len() == 0) return 0; // nothing was changed!
     81                        if (tmp.length() == 0) return 0; // nothing was changed!
    8282                        tmp += x;
    8383                        target = tmp;
    … …  
    112112                else
    113113                {
    114                         if (tmp.len() == 0) return 0; // nothing was changed!
     114                        if (tmp.length() == 0) return 0; // nothing was changed!
    115115                        tmp += x;
    116116                        target = tmp;
    … …  
    139139        bool changed = 0;
    140140        SString tmp;
    141         tmp.memoryHint(target.len());
     141        tmp.reserve(target.length());
    142142        while (*x)
    143143        {
    … …  
    160160{
    161161        SString out;
    162         if (in.len() > maxlen)
    163                 out = in.substr(0, maxlen / 2) + "..." + in.substr(in.len() - maxlen + maxlen / 2);
     162        if (in.length() > maxlen)
     163                out = in.substr(0, maxlen / 2) + "..." + in.substr(in.length() - maxlen + maxlen / 2);
    164164        else
    165165        {
    … …  
    169169        out = before + out + after;
    170170        if (show_length)
    171                 out += SString::sprintf(" (length %d)", in.len());
     171                out += SString::sprintf(" (length %d)", in.length());
    172172        return out;
    173173}
    … …  
    208208                else
    209209                {
    210                         if (tmp.len() == 0) return 0; // nothing was changed!
     210                        if (tmp.length() == 0) return 0; // nothing was changed!
    211211                        tmp += x;
    212212                        target = tmp;
    … …  
    223223        {
    224224                n = strchr(t + pos, ',');
    225                 if ((!strncmp(t + pos, name.c_str(), name.len())) && (t[pos + name.len()] == '='))
    226                 {
    227                         if (n) end = n - t; else end = txt.len();
     225                if ((!strncmp(t + pos, name.c_str(), name.length())) && (t[pos + name.length()] == '='))
     226                {
     227                        if (n) end = n - t; else end = txt.length();
    228228                        return pos;
    229229                }
    … …  
    238238        p = strFindField(txt, name, e);
    239239        if (p < 0) return SString();
    240         p += name.len() + 1;
     240        p += name.length() + 1;
    241241        return SString(txt.substr(p, e - p));
    242242}
    … …  
    248248        if (p < 0)
    249249        {
    250                 if (!value.len()) return;
    251                 char *t = txt.directAppend(1 + name.len() + value.len());
     250                if (!value.length()) return;
     251                char *t = txt.directAppend(1 + name.length() + value.length());
    252252                char *b = t;
    253                 if (txt.len()) *(t++) = ',';
    254                 strcpy(t, name.c_str()); t += name.len();
     253                if (txt.length()) *(t++) = ',';
     254                strcpy(t, name.c_str()); t += name.length();
    255255                *(t++) = '=';
    256                 strcpy(t, value.c_str()); t += value.len();
     256                strcpy(t, value.c_str()); t += value.length();
    257257                txt.endAppend(t - b);
    258258        }
    259259        else
    260260        {
    261                 if (!value.len())
    262                 {
    263                         if (p > 0) p--; else if (e < txt.len()) e++;
     261                if (!value.length())
     262                {
     263                        if (p > 0) p--; else if (e < txt.length()) e++;
    264264                        char *t = txt.directWrite(0);
    265                         memmove(t + p, t + e, txt.len() - e);
    266                         txt.endWrite(txt.len() + value.len() - (e - p));
    267                 }
    268                 else
    269                 {
    270                         p += name.len() + 1;
    271                         char *t = txt.directWrite(txt.len() + value.len() - (e - p));
    272                         memmove(t + p + value.len(), t + e, txt.len() - e);
    273                         memmove(t + p, value.c_str(), value.len());
    274                         txt.endWrite(txt.len() + value.len() - (e - p));
     265                        memmove(t + p, t + e, txt.length() - e);
     266                        txt.endWrite(txt.length() + value.length() - (e - p));
     267                }
     268                else
     269                {
     270                        p += name.length() + 1;
     271                        char *t = txt.directWrite(txt.length() + value.length() - (e - p));
     272                        memmove(t + p + value.length(), t + e, txt.length() - e);
     273                        memmove(t + p, value.c_str(), value.length());
     274                        txt.endWrite(txt.length() + value.length() - (e - p));
    275275                }
    276276        }
    … …  
    280280{
    281281        const unsigned char*b = (const unsigned char*)s.c_str();
    282         const unsigned char*e = b + s.len();
     282        const unsigned char*e = b + s.length();
    283283        while ((b < e) && (*b <= ' ')) b++;
    284284        while ((b < e) && (e[-1] <= ' ')) e--;
    285         if ((e - b) == s.len()) return s;
     285        if ((e - b) == s.length()) return s;
    286286        SString newstring;
    287287        char* t = newstring.directWrite(e - b);
    … …  
    291291}
    292292
    293 SString concatPath(const SString& in1,const SString& in2)
    294 {
    295         SString out=in1;
    296         if (out.len()>0 && out[out.len()-1]!=PATH_SEPARATOR_CHAR)
    297                 out+=PATH_SEPARATOR_CHAR;
    298         out+=in2;
     293SString concatPath(const SString& in1, const SString& in2)
     294{
     295        SString out = in1;
     296        if (out.length() > 0 && out[out.length() - 1] != PATH_SEPARATOR_CHAR)
     297                out += PATH_SEPARATOR_CHAR;
     298        out += in2;
    299299        return out;
    300300}
    … …  
    318318bool matchWildcard(const SString& word, const SString& pattern)
    319319{
    320         if (pattern.len() == 0)
    321                 return word.len() == 0;
     320        if (pattern.length() == 0)
     321                return word.length() == 0;
    322322        int aster = pattern.indexOf('*');
    323323        if (aster >= 0)
    … …  
    325325                SString before = pattern.substr(0, aster);
    326326                SString after = pattern.substr(aster + 1);
    327                 if (!word.len()) return false;
    328                 if (before.len()) if (!word.startsWith(before.c_str())) return false;
    329                 if (after.len())
    330                         if ((word.len() < after.len())
    331                                 || (strcmp(after.c_str(), word.c_str() + word.len() - after.len())))
     327                if (!word.length()) return false;
     328                if (before.length()) if (!word.startsWith(before.c_str())) return false;
     329                if (after.length())
     330                        if ((word.length() < after.length())
     331                                || (strcmp(after.c_str(), word.c_str() + word.length() - after.length())))
    332332                                return false;
    333333                return true;
    … …  
    339339bool matchWildcardList(const SString& word, const SString& patterns)
    340340{
    341         if (patterns.len() == 0)
    342                 return word.len() == 0;
     341        if (patterns.length() == 0)
     342                return word.length() == 0;
    343343        int pos = 0;
    344344        SString pattern;

  • cpp/frams/util/sstringutils.h

    r929 r973  
    4040        int i, next = 0;
    4141        bool first = true;
    42         if (!separator.len()) { result.push_back(text); return; }
     42        if (!separator.length()) { result.push_back(text); return; }
    4343        while (1)
    4444        {
    … …  
    4646                if (i < 0)
    4747                {
    48                         if ((next <= text.len()) || first)
     48                        if ((next <= text.length()) || first)
    4949                                result.push_back(text.substr(next));
    5050                        return;
    … …  
    5555                        first = false;
    5656                }
    57                 next = i + separator.len();
     57                next = i + separator.length();
    5858        }
    5959}
Note: See TracChangeset for help on using the changeset viewer.