Changeset 793 for cpp/frams/util/sstring-simple.cpp

Timestamp:

05/29/18 16:51:14 (6 years ago)

Author:

Maciej Komosinski

Message:

Code formatting

File:

• cpp/frams/util/sstring-simple.cpp (modified) (6 diffs)

cpp/frams/util/sstring-simple.cpp

@@ -6 +6 @@
 void SString::initEmpty()
 {
-txt=NULL; used=0; size=0;
+        txt = NULL; used = 0; size = 0;
 }
 
 SString::SString()
 {
-initEmpty();
+        initEmpty();
 }
 
 SString::~SString()
 {
-resize(0);
+        resize(0);
 }
 
 SString::SString(int x)
 {
-initEmpty();
-if (x)
-        ensureSize(x+1);
-}
-
-SString::SString(const char *t,int t_len)
-{
-initEmpty();
-if (!t) return;
-copyFrom(t,t_len);
+        initEmpty();
+        if (x)
+                ensureSize(x + 1);
+}
+
+SString::SString(const char *t, int t_len)
+{
+        initEmpty();
+        if (!t) return;
+        copyFrom(t, t_len);
 }
 
 SString::SString(const SString &from)
 {
-initEmpty();
-operator=(from);
+        initEmpty();
+        operator=(from);
 }
 
 SString::SString(SString&& from)
 {
-txt=from.txt; size=from.size; used=from.used;
-from.txt=NULL; from.size=0; from.used=0;
+        txt = from.txt; size = from.size; used = from.used;
+        from.txt = NULL; from.size = 0; from.used = 0;
 }
 
 void SString::resize(int newsize)
 {
-if (newsize==size) return;
-txt=(char*)realloc(txt,newsize);
-size=newsize;
+        if (newsize == size) return;
+        txt = (char*)realloc(txt, newsize);
+        size = newsize;
 }
 
 void SString::ensureSize(int needed)
 {
-if (size>needed) return;
-resize( (size>0) ? (needed+needed/2+1) : (needed+1));
+        if (size > needed) return;
+        resize((size > 0) ? (needed + needed / 2 + 1) : (needed + 1));
 }
 
 char *SString::directWrite(int ensuresize)
 {
-ensureSize(ensuresize);
-appending=used;
-return txt;
+        ensureSize(ensuresize);
+        appending = used;
+        return txt;
 }
 
 char *SString::directAppend(int maxappend)
 {
-ensureSize(used+maxappend);
-appending=used;
-return txt+appending;
+        ensureSize(used + maxappend);
+        appending = used;
+        return txt + appending;
 }
 
 void SString::endWrite(int newlength)
 {
-if (newlength<0) newlength=strlen(txt);
-else txt[newlength]=0;
-used=newlength;
-assert(used<size);
+        if (newlength < 0) newlength = strlen(txt);
+        else txt[newlength] = 0;
+        used = newlength;
+        assert(used < size);
 }
 
 void SString::endAppend(int newappend)
 {
-if (newappend<0) newappend=strlen(txt+appending);
-else txt[appending+newappend]=0;
-used=appending+newappend;
-assert(used<size);
+        if (newappend < 0) newappend = strlen(txt + appending);
+        else txt[appending + newappend] = 0;
+        used = appending + newappend;
+        assert(used < size);
 }
 
@@ -92 +92 @@
 void SString::operator+=(const char *s)
 {
-if (!s) return;
-int x=strlen(s);
-if (!x) return;
-append(s,x);
-}
-
-void SString::append(const char *t,int n)
-{
-if (!n) return;
-ensureSize(used+n);
-memmove(txt+used,t,n);
-used+=n;
-txt[used]=0;
+        if (!s) return;
+        int x = strlen(s);
+        if (!x) return;
+        append(s, x);
+}
+
+void SString::append(const char *t, int n)
+{
+        if (!n) return;
+        ensureSize(used + n);
+        memmove(txt + used, t, n);
+        used += n;
+        txt[used] = 0;
 }
 
 void SString::operator+=(const SString&s)
 {
-append(s.c_str(),s.len());
+        append(s.c_str(), s.len());
 }
 
 SString SString::operator+(const SString& s) const
 {
-SString ret(len()+s.len());
-ret=*this;
-ret+=s;
-return ret;
+        SString ret(len() + s.len());
+        ret = *this;
+        ret += s;
+        return ret;
 }
 
 /////////////////////////////
 
-void SString::copyFrom(const char *ch,int chlen)
-{
-if (!ch) chlen=0;
-else if (chlen<0) chlen=strlen(ch);
-if (chlen)
+void SString::copyFrom(const char *ch, int chlen)
+{
+        if (!ch) chlen = 0;
+        else if (chlen < 0) chlen = strlen(ch);
+        if (chlen)
         {
-        ensureSize(chlen);
-        memmove(txt,ch,chlen);
-        txt[chlen]=0;
-        used=chlen;
+                ensureSize(chlen);
+                memmove(txt, ch, chlen);
+                txt[chlen] = 0;
+                used = chlen;
         }
-else
+        else
         {
-        if (txt)
+                if (txt)
                 {
-                txt[0]=0;
-                used=0;
+                        txt[0] = 0;
+                        used = 0;
                 }
         }
@@ -145 +145 @@
 void SString::operator=(const char *ch)
 {
-copyFrom(ch);
+        copyFrom(ch);
 }
 
 void SString::operator=(const SString&s)
 {
-if (&s==this) return;
-copyFrom(s.c_str(),s.len());
+        if (&s == this) return;
+        copyFrom(s.c_str(), s.len());
 }
 
@@ -158 +158 @@
 SString SString::substr(int begin, int length) const
 {
-if (begin<0) { length+=begin; begin=0; }
-if (length>=(len()-begin)) length=len()-begin;
-if (length<=0) return SString();
-if (length==len()) return *this;
-return SString((*this)(begin),length);
+        if (begin < 0) { length += begin; begin = 0; }
+        if (length >= (len() - begin)) length = len() - begin;
+        if (length <= 0) return SString();
+        if (length == len()) return *this;
+        return SString((*this)(begin), length);
 }
 
@@ -169 +169 @@
 bool SString::equals(const SString& s) const
 {
-if (this==&s) return true;
-if (len()!=s.len()) return false;
-return strcmp(getPtr(),s.getPtr())==0;
+        if (this == &s) return true;
+        if (len() != s.len()) return false;
+        return strcmp(getPtr(), s.getPtr()) == 0;
 }
 
 ///////////////////////////////////////
 
-int SString::indexOf(int character,int start) const
-{
-const char *found=strchr(getPtr()+start,character);
-return found?found-getPtr():-1;
-}
-
-int SString::indexOf(const char *substring,int start) const
-{
-const char *found=strstr(getPtr()+start,substring);
-return found?found-getPtr():-1;
-}
-
-int SString::indexOf(const SString & substring,int start) const
-{
-const char *found=strstr(getPtr()+start,substring.c_str());
-return found?found-getPtr():-1;
-}
-
-bool SString::getNextToken (int& pos,SString &token,char separator) const
-{
-if (pos>=len()) {token=0;return false;}
-int p1=pos,p2;
-const char *t1=getPtr()+pos;
-const char *t2=strchr(t1,separator);
-if (t2) pos=(p2=(t2-getPtr()))+1; else p2=pos=len();
-strncpy(token.directWrite(p2-p1),t1,p2-p1);
-token.endWrite(p2-p1);
-return true;
+int SString::indexOf(int character, int start) const
+{
+        const char *found = strchr(getPtr() + start, character);
+        return found ? found - getPtr() : -1;
+}
+
+int SString::indexOf(const char *substring, int start) const
+{
+        const char *found = strstr(getPtr() + start, substring);
+        return found ? found - getPtr() : -1;
+}
+
+int SString::indexOf(const SString & substring, int start) const
+{
+        const char *found = strstr(getPtr() + start, substring.c_str());
+        return found ? found - getPtr() : -1;
+}
+
+bool SString::getNextToken(int& pos, SString &token, char separator) const
+{
+        if (pos >= len()) { token = 0; return false; }
+        int p1 = pos, p2;
+        const char *t1 = getPtr() + pos;
+        const char *t2 = strchr(t1, separator);
+        if (t2) pos = (p2 = (t2 - getPtr())) + 1; else p2 = pos = len();
+        strncpy(token.directWrite(p2 - p1), t1, p2 - p1);
+        token.endWrite(p2 - p1);
+        return true;
 }
 
 bool SString::startsWith(const char *pattern) const
 {
-const char *t=this->c_str();
-for (;*pattern;pattern++,t++)
-        if (*t != *pattern) return false;
-return true;
+        const char *t = this->c_str();
+        for (; *pattern; pattern++, t++)
+                if (*t != *pattern) return false;
+        return true;
 }
 
 SString SString::valueOf(int i)
 {
-return SString::sprintf("%d",i);
+        return SString::sprintf("%d", i);
 }
 SString SString::valueOf(long i)
 {
-return SString::sprintf("%d",i);
+        return SString::sprintf("%d", i);
 }
 SString SString::valueOf(double d)
 {
-SString tmp=SString::sprintf("%.15g",d);
-if ((!strchr(tmp.c_str(),'.'))&&(!strchr(tmp.c_str(),'e'))) tmp+=".0";
-return tmp;
+        SString tmp = SString::sprintf("%.15g", d);
+        if ((!strchr(tmp.c_str(), '.')) && (!strchr(tmp.c_str(), 'e'))) tmp += ".0";
+        return tmp;
 }
 SString SString::valueOf(const SString& s)
 {
-return s;
+        return s;
 }
 
 SString SString::sprintf(const char* format, ...)
 {
-int n, size = 30;
-va_list ap;
-
-SString ret;
+        int n, size = 30;
+        va_list ap;
+
+        SString ret;
 
 #ifdef USE_VSCPRINTF
-va_start(ap, format);
-size=_vscprintf(format, ap);
-va_end(ap);
+        va_start(ap, format);
+        size = _vscprintf(format, ap);
+        va_end(ap);
 #endif
 
-while (1)
+        while (1)
         {
-        char* p=ret.directWrite(size);
-        assert(p!=NULL);
-        size=ret.directMaxLen()+1;
-        /* Try to print in the allocated space. */
-        va_start(ap, format);
-        n = vsnprintf(p, size, format, ap);
-        va_end(ap);
-        /* If that worked, return the string. */
-        if (n > -1 && n < size)
+                char* p = ret.directWrite(size);
+                assert(p != NULL);
+                size = ret.directMaxLen() + 1;
+                /* Try to print in the allocated space. */
+                va_start(ap, format);
+                n = vsnprintf(p, size, format, ap);
+                va_end(ap);
+                /* If that worked, return the string. */
+                if (n > -1 && n < size)
                 {
-                ret.endWrite(n);
-                return ret;
+                        ret.endWrite(n);
+                        return ret;
                 }
-        /* Else try again with more space. */
+                /* Else try again with more space. */
 #ifdef VSNPRINTF_RETURNS_REQUIRED_SIZE
-        if (n > -1)    /* glibc 2.1 */
-                size = n; /* precisely what is needed */
-        else           /* glibc 2.0 */
+                if (n > -1)    /* glibc 2.1 */
+                        size = n; /* precisely what is needed */
+                else           /* glibc 2.0 */
 #endif
-                size *= 2;  /* twice the old size */
+                        size *= 2;  /* twice the old size */
         }
 }
@@ -273 +273 @@
 SString &SString::empty()
 {
-static SString empty;
-return empty;
-}
+        static SString empty;
+        return empty;
+}