WDL/wdlstring.h

   1 /*
   2     WDL - wdlstring.h
   3     Copyright (C) 2005 and later, Cockos Incorporated
   4
   5     This software is provided 'as-is', without any express or implied
   6     warranty.  In no event will the authors be held liable for any damages
   7     arising from the use of this software.
   8
   9     Permission is granted to anyone to use this software for any purpose,
  10     including commercial applications, and to alter it and redistribute it
  11     freely, subject to the following restrictions:
  12
  13     1. The origin of this software must not be misrepresented; you must not
  14        claim that you wrote the original software. If you use this software
  15        in a product, an acknowledgment in the product documentation would be
  16        appreciated but is not required.
  17     2. Altered source versions must be plainly marked as such, and must not be
  18        misrepresented as being the original software.
  19     3. This notice may not be removed or altered from any source distribution.
  20
  21 */
  22
  23 /*
  24
  25   This file provides a simple class for variable-length string manipulation.
  26   It provides only the simplest features, and does not do anything confusing like
  27   operator overloading. It uses a WDL_HeapBuf for internal storage.
  28
  29   Actually: there are WDL_String and WDL_FastString -- the latter's Get() returns const char, and tracks
  30   the length of the string, which is often faster. Because of this, you are not permitted to directly modify
  31   the buffer returned by Get().
  32
  33
  34 */
  35
  36 #ifndef _WDL_STRING_H_
  37 #define _WDL_STRING_H_
  38
  39 #include "heapbuf.h"
  40 #include <stdio.h>
  41 #include <stdarg.h>
  42
  43 #ifndef WDL_STRING_IMPL_ONLY
  44 class WDL_String
  45 {
  46   public:
  47   #ifdef WDL_STRING_INTF_ONLY
  48     void Set(const char *str, int maxlen=0);
  49     void Set(const WDL_String *str, int maxlen=0);
  50     void Append(const char *str, int maxlen=0);
  51     void Append(const WDL_String *str, int maxlen=0);
  52     void DeleteSub(int position, int len);
  53     void Insert(const char *str, int position, int maxlen=0);
  54     void Insert(const WDL_String *str, int position, int maxlen=0);
  55     #ifdef WDL_STRING_FASTSUB_DEFINED
  56     bool SetLen(int length, bool resizeDown=false, char fillchar=' '); // returns true on success
  57     #else
  58     bool SetLen(int length, bool resizeDown=false); // returns true on success
  59     #endif
  60     void Ellipsize(int minlen, int maxlen);
  61     const char *get_filepart() const; // returns whole string if no dir chars
  62     const char *get_fileext() const; // returns ".ext" or end of string "" if no extension
  63     bool remove_fileext(); // returns true if extension was removed
  64     char remove_filepart(bool keepTrailingSlash=false); // returns dir character used, or zero if string emptied
  65     int remove_trailing_dirchars(); // returns trailing dirchar count removed, will not convert "/" into ""
  66
  67     void SetAppendFormattedArgs(bool append, int maxlen, const char* fmt, va_list arglist);
  68     void WDL_VARARG_WARN(printf,3,4) SetFormatted(int maxlen, const char *fmt, ...);
  69     void WDL_VARARG_WARN(printf,3,4) AppendFormatted(int maxlen, const char *fmt, ...);
  70   #endif
  71
  72     const char *Get() const { return m_hb.GetSize()?(char*)m_hb.Get():""; }
  73     const char *GetAtOffs(int offs) const {
  74       const int l = GetLength();
  75       if (WDL_NOT_NORMALLY(offs < 0 || offs > l)) return Get()+l;
  76       return Get()+offs;
  77     }
  78
  79   #ifdef WDL_STRING_FASTSUB_DEFINED
  80     int GetLength() const { int a = m_hb.GetSize(); return a>0?a-1:0; }
  81
  82     // for binary-safe manipulations
  83     void SetRaw(const char *str, int len) { __doSet(0,str,len,0); }
  84     void AppendRaw(const char *str, int len) { __doSet(GetLength(),str,len,0); }
  85     void InsertRaw(const char *str, int position, int ilen)
  86     {
  87       const int srclen = GetLength();
  88       if (position<0) position=0;
  89       else if (position>srclen) position=srclen;
  90       if (ilen>0) __doSet(position,str,ilen,srclen-position);
  91     }
  92
  93   #else
  94     char *Get()
  95     {
  96       if (m_hb.GetSize()) return (char *)m_hb.Get();
  97       static char c; c=0; return &c; // don't return "", in case it gets written to.
  98     }
  99     int GetLength() const { return m_hb.GetSize()?(int)strlen((const char*)m_hb.Get()):0; }
 100   #endif
 101
 102     explicit WDL_String(int hbgran) : m_hb(hbgran) { }
 103     explicit WDL_String(const char *initial=NULL, int initial_len=0) : m_hb(128)
 104     {
 105       if (initial) Set(initial,initial_len);
 106     }
 107     WDL_String(const WDL_String &s) : m_hb(128) { Set(&s); }
 108     WDL_String(const WDL_String *s) : m_hb(128) { if (s && s != this) Set(s); }
 109     ~WDL_String() { }
 110 #endif // ! WDL_STRING_IMPL_ONLY
 111
 112 #ifndef WDL_STRING_INTF_ONLY
 113   #ifdef WDL_STRING_IMPL_ONLY
 114     #define WDL_STRING_FUNCPREFIX WDL_String::
 115     #define WDL_STRING_DEFPARM(x)
 116   #else
 117     #define WDL_STRING_FUNCPREFIX
 118     #define WDL_STRING_DEFPARM(x) =(x)
 119   #endif
 120
 121     void WDL_STRING_FUNCPREFIX Set(const char *str, int maxlen WDL_STRING_DEFPARM(0))
 122     {
 123       int s=0;
 124       if (str)
 125       {
 126         if (maxlen>0) while (s < maxlen && str[s]) s++;
 127         else s=(int)strlen(str);
 128       }
 129       __doSet(0,str,s,0);
 130     }
 131
 132     void WDL_STRING_FUNCPREFIX Set(const WDL_String *str, int maxlen WDL_STRING_DEFPARM(0))
 133     {
 134       #ifdef WDL_STRING_FASTSUB_DEFINED
 135         int s = str ? str->GetLength() : 0;
 136         if (maxlen>0 && maxlen<s) s=maxlen;
 137
 138         __doSet(0,str?str->Get():NULL,s,0);
 139       #else
 140         Set(str?str->Get():NULL, maxlen); // might be faster: "partial" strlen
 141       #endif
 142     }
 143
 144     void WDL_STRING_FUNCPREFIX Append(const char *str, int maxlen WDL_STRING_DEFPARM(0))
 145     {
 146       int s=0;
 147       if (str)
 148       {
 149         if (maxlen>0) while (s < maxlen && str[s]) s++;
 150         else s=(int)strlen(str);
 151       }
 152
 153       __doSet(GetLength(),str,s,0);
 154     }
 155
 156     void WDL_STRING_FUNCPREFIX Append(const WDL_String *str, int maxlen WDL_STRING_DEFPARM(0))
 157     {
 158       #ifdef WDL_STRING_FASTSUB_DEFINED
 159         int s = str ? str->GetLength() : 0;
 160         if (maxlen>0 && maxlen<s) s=maxlen;
 161
 162         __doSet(GetLength(),str?str->Get():NULL,s,0);
 163       #else
 164         Append(str?str->Get():NULL, maxlen); // might be faster: "partial" strlen
 165       #endif
 166     }
 167
 168     void WDL_STRING_FUNCPREFIX DeleteSub(int position, int len)
 169     {
 170       int l=m_hb.GetSize()-1;
 171       char *p=(char *)m_hb.Get();
 172       if (l<0 || !*p || position < 0 || position >= l) return;
 173       if (position+len > l) len=l-position;
 174       if (len>0)
 175       {
 176         memmove(p+position,p+position+len,l-position-len+1);
 177         m_hb.Resize(l+1-len,false);
 178       }
 179     }
 180
 181     void WDL_STRING_FUNCPREFIX Insert(const char *str, int position, int maxlen WDL_STRING_DEFPARM(0))
 182     {
 183       int ilen=0;
 184       if (str)
 185       {
 186         if (maxlen>0) while (ilen < maxlen && str[ilen]) ilen++;
 187         else ilen=(int)strlen(str);
 188       }
 189
 190       const int srclen = GetLength();
 191       if (position<0) position=0;
 192       else if (position>srclen) position=srclen;
 193       if (ilen>0) __doSet(position,str,ilen,srclen-position);
 194     }
 195
 196     void WDL_STRING_FUNCPREFIX Insert(const WDL_String *str, int position, int maxlen WDL_STRING_DEFPARM(0))
 197     {
 198       #ifdef WDL_STRING_FASTSUB_DEFINED
 199         int ilen = str ? str->GetLength() : 0;
 200         if (maxlen>0 && maxlen<ilen) ilen=maxlen;
 201
 202         const int srclen = m_hb.GetSize()>0 ? m_hb.GetSize()-1 : 0;
 203         if (position<0) position=0;
 204         else if (position>srclen) position=srclen;
 205         if (ilen>0) __doSet(position,str->Get(),ilen,srclen-position);
 206       #else
 207         Insert(str?str->Get():NULL, position, maxlen); // might be faster: "partial" strlen
 208       #endif
 209     }
 210
 211     bool WDL_STRING_FUNCPREFIX SetLen(int length, bool resizeDown WDL_STRING_DEFPARM(false)
 212       #ifdef WDL_STRING_FASTSUB_DEFINED
 213         , char fillchar WDL_STRING_DEFPARM(' ')
 214       #endif
 215         )
 216     {
 217       #ifdef WDL_STRING_FASTSUB_DEFINED
 218       int osz = m_hb.GetSize()-1;
 219       if (osz<0)osz=0;
 220       #endif
 221       if (length < 0) length=0;
 222       char *b=(char*)m_hb.ResizeOK(length+1,resizeDown);
 223       if (b)
 224       {
 225         #ifdef WDL_STRING_FASTSUB_DEFINED
 226           const int fill = length-osz;
 227           if (fill > 0) memset(b+osz,fillchar,fill);
 228         #endif
 229         b[length]=0;
 230         return true;
 231       }
 232       return false;
 233     }
 234
 235     void WDL_STRING_FUNCPREFIX SetAppendFormattedArgs(bool append, int maxlen, const char* fmt, va_list arglist)
 236     {
 237       int offs = append ? GetLength() : 0;
 238       char *b= (char*) m_hb.ResizeOK(offs+maxlen+1,false);
 239
 240       if (!b) return;
 241
 242       b+=offs;
 243
 244       #ifdef _WIN32
 245         int written = _vsnprintf(b, maxlen+1, fmt, arglist);
 246         if (written < 0 || written>=maxlen) b[written=b[0]?maxlen:0]=0;
 247       #else
 248         int written = vsnprintf(b, maxlen+1, fmt, arglist);
 249         if (written > maxlen) written=maxlen;
 250       #endif
 251
 252       m_hb.Resize(offs + written + 1,false);
 253     }
 254
 255     void WDL_VARARG_WARN(printf,3,4) WDL_STRING_FUNCPREFIX SetFormatted(int maxlen, const char *fmt, ...)
 256     {
 257       va_list arglist;
 258       va_start(arglist, fmt);
 259       SetAppendFormattedArgs(false,maxlen,fmt,arglist);
 260       va_end(arglist);
 261     }
 262
 263     void WDL_VARARG_WARN(printf,3,4) WDL_STRING_FUNCPREFIX AppendFormatted(int maxlen, const char *fmt, ...)
 264     {
 265       va_list arglist;
 266       va_start(arglist, fmt);
 267       SetAppendFormattedArgs(true,maxlen,fmt,arglist);
 268       va_end(arglist);
 269     }
 270
 271     void WDL_STRING_FUNCPREFIX Ellipsize(int minlen, int maxlen)
 272     {
 273       if (maxlen >= 4 && m_hb.GetSize() && GetLength() > maxlen)
 274       {
 275         if (minlen<0) minlen=0;
 276         char *b = (char *)m_hb.Get();
 277         int i;
 278         for (i = maxlen-4; i >= minlen; --i)
 279         {
 280           if (b[i] == ' ')
 281           {
 282             memcpy(b+i, "...",4);
 283             m_hb.Resize(i+4,false);
 284             break;
 285           }
 286         }
 287         if (i < minlen && maxlen >= 4)
 288         {
 289           memcpy(b+maxlen-4, "...",4);
 290           m_hb.Resize(maxlen,false);
 291         }
 292       }
 293     }
 294     const char * WDL_STRING_FUNCPREFIX get_filepart() const // returns whole string if no dir chars
 295     {
 296       const char *s = Get();
 297       const char *p = s + GetLength() - 1;
 298       while (p >= s && !WDL_IS_DIRCHAR(*p)) --p;
 299       return p + 1;
 300     }
 301     const char * WDL_STRING_FUNCPREFIX get_fileext() const // returns ".ext" or end of string "" if no extension
 302     {
 303       const char *s = Get();
 304       const char *endp = s + GetLength();
 305       const char *p = endp - 1;
 306       while (p >= s && !WDL_IS_DIRCHAR(*p))
 307       {
 308         if (*p == '.') return p;
 309         --p;
 310       }
 311       return endp;
 312     }
 313     bool WDL_STRING_FUNCPREFIX remove_fileext() // returns true if extension was removed
 314     {
 315       const char *str = Get();
 316       int pos = GetLength() - 1;
 317       while (pos >= 0)
 318       {
 319         char c = str[pos];
 320         if (WDL_IS_DIRCHAR(c)) break;
 321         if (c == '.')
 322         {
 323           SetLen(pos);
 324           return true;
 325         }
 326         --pos;
 327       }
 328       return false;
 329     }
 330
 331     char WDL_STRING_FUNCPREFIX remove_filepart(bool keepTrailingSlash WDL_STRING_DEFPARM(false)) // returns directory character used, or 0 if string emptied
 332     {
 333       char rv=0;
 334       const char *str = Get();
 335       int pos = GetLength() - 1;
 336       while (pos > 0)
 337       {
 338         char c = str[pos];
 339         if (WDL_IS_DIRCHAR(c))
 340         {
 341           rv=c;
 342           if (keepTrailingSlash) ++pos;
 343           break;
 344         }
 345         --pos;
 346       }
 347       SetLen(pos);
 348       return rv;
 349     }
 350
 351     int WDL_STRING_FUNCPREFIX remove_trailing_dirchars() // returns trailing dirchar count removed
 352     {
 353       int cnt = 0;
 354       const char *str = Get();
 355       const int l = GetLength()-1;
 356       while (cnt < l)
 357       {
 358         char c = str[l - cnt];
 359         if (!WDL_IS_DIRCHAR(c)) break;
 360         ++cnt;
 361       }
 362       if (cnt > 0) SetLen(l + 1 - cnt);
 363       return cnt;
 364     }
 365 #ifndef WDL_STRING_IMPL_ONLY
 366   private:
 367 #endif
 368     void WDL_STRING_FUNCPREFIX __doSet(int offs, const char *str, int len, int trailkeep)
 369     {
 370       // if non-empty, or (empty and allocated and Set() rather than append/insert), then allow update, otherwise do nothing
 371       if (len==0 && !trailkeep && !offs)
 372       {
 373         #ifdef WDL_STRING_FREE_ON_CLEAR
 374           m_hb.Resize(0,true);
 375         #else
 376           char *p = (char *)m_hb.ResizeOK(1,false);
 377           if (p) *p=0;
 378         #endif
 379       }
 380       else if (len>0 && offs >= 0)
 381       {
 382         const int oldsz = m_hb.GetSize();
 383         const int newsz=offs+len+trailkeep+1;
 384         const int growamt = newsz-oldsz;
 385         if (growamt > 0)
 386         {
 387           const char *oldb = (const char *)m_hb.Get();
 388           const char *newb = (const char *)m_hb.ResizeOK(newsz,false); // resize up if necessary
 389
 390           // in case str overlaps with input, keep it valid
 391           if (str && newb != oldb && str >= oldb && str < oldb+oldsz) str = newb + (str - oldb);
 392         }
 393
 394         if (m_hb.GetSize() >= newsz)
 395         {
 396           char *newbuf = (char *)m_hb.Get();
 397           if (trailkeep>0) memmove(newbuf+offs+len,newbuf+offs,trailkeep);
 398           if (str) memmove(newbuf+offs,str,len);
 399           newbuf[newsz-1]=0;
 400
 401           // resize down if necessary
 402           if (growamt < 0) m_hb.Resize(newsz,false);
 403         }
 404       }
 405     }
 406
 407   #undef WDL_STRING_FUNCPREFIX
 408   #undef WDL_STRING_DEFPARM
 409 #endif // ! WDL_STRING_INTF_ONLY
 410
 411 #ifndef WDL_STRING_IMPL_ONLY
 412
 413   private:
 414     #ifdef WDL_STRING_INTF_ONLY
 415       void __doSet(int offs, const char *str, int len, int trailkeep);
 416     #endif
 417
 418     WDL_HeapBuf m_hb;
 419 };
 420 #endif
 421
 422 #ifndef WDL_STRING_FASTSUB_DEFINED
 423 #undef _WDL_STRING_H_
 424 #define WDL_STRING_FASTSUB_DEFINED
 425 #define WDL_String WDL_FastString
 426 #include "wdlstring.h"
 427 #undef WDL_STRING_FASTSUB_DEFINED
 428 #undef WDL_String
 429 #endif
 430
 431 #endif
 432