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     void SetLen(int length, bool resizeDown=false);
  56     void Ellipsize(int minlen, int maxlen);
  57     const char *get_filepart() const; // returns whole string if no dir chars
  58     const char *get_fileext() const; // returns ".ext" or end of string "" if no extension
  59     bool remove_fileext(); // returns true if extension was removed
  60     char remove_filepart(bool keepTrailingSlash=false); // returns dir character used, or zero if string emptied
  61     int remove_trailing_dirchars(); // returns trailing dirchar count removed, will not convert "/" into ""
  62
  63     void SetAppendFormattedArgs(bool append, int maxlen, const char* fmt, va_list arglist);
  64     void WDL_VARARG_WARN(printf,3,4) SetFormatted(int maxlen, const char *fmt, ...);
  65     void WDL_VARARG_WARN(printf,3,4) AppendFormatted(int maxlen, const char *fmt, ...);
  66   #endif
  67
  68     const char *Get() const { return m_hb.GetSize()?(char*)m_hb.Get():""; }
  69
  70   #ifdef WDL_STRING_FASTSUB_DEFINED
  71     int GetLength() const { int a = m_hb.GetSize(); return a>0?a-1:0; }
  72
  73     // for binary-safe manipulations
  74     void SetRaw(const char *str, int len) { __doSet(0,str,len,0); }
  75     void AppendRaw(const char *str, int len) { __doSet(GetLength(),str,len,0); }
  76     void InsertRaw(const char *str, int position, int ilen)
  77     {
  78       const int srclen = GetLength();
  79       if (position<0) position=0;
  80       else if (position>srclen) position=srclen;
  81       if (ilen>0) __doSet(position,str,ilen,srclen-position);
  82     }
  83
  84   #else
  85     char *Get()
  86     {
  87       if (m_hb.GetSize()) return (char *)m_hb.Get();
  88       static char c; c=0; return &c; // don't return "", in case it gets written to.
  89     }
  90     int GetLength() const { return m_hb.GetSize()?(int)strlen((const char*)m_hb.Get()):0; }
  91   #endif
  92
  93     explicit WDL_String(int hbgran) : m_hb(hbgran WDL_HEAPBUF_TRACEPARM("WDL_String(4)")) { }
  94     explicit WDL_String(const char *initial=NULL, int initial_len=0) : m_hb(128 WDL_HEAPBUF_TRACEPARM("WDL_String"))
  95     {
  96       if (initial) Set(initial,initial_len);
  97     }
  98     WDL_String(const WDL_String &s) : m_hb(128 WDL_HEAPBUF_TRACEPARM("WDL_String(2)")) { Set(&s); }
  99     WDL_String(const WDL_String *s) : m_hb(128 WDL_HEAPBUF_TRACEPARM("WDL_String(3)")) { if (s && s != this) Set(s); }
 100     ~WDL_String() { }
 101 #endif // ! WDL_STRING_IMPL_ONLY
 102
 103 #ifndef WDL_STRING_INTF_ONLY
 104   #ifdef WDL_STRING_IMPL_ONLY
 105     #define WDL_STRING_FUNCPREFIX WDL_String::
 106     #define WDL_STRING_DEFPARM(x)
 107   #else
 108     #define WDL_STRING_FUNCPREFIX
 109     #define WDL_STRING_DEFPARM(x) =(x)
 110   #endif
 111
 112     void WDL_STRING_FUNCPREFIX Set(const char *str, int maxlen WDL_STRING_DEFPARM(0))
 113     {
 114       int s=0;
 115       if (str)
 116       {
 117         if (maxlen>0) while (s < maxlen && str[s]) s++;
 118         else s=(int)strlen(str);
 119       }
 120       __doSet(0,str,s,0);
 121     }
 122
 123     void WDL_STRING_FUNCPREFIX Set(const WDL_String *str, int maxlen WDL_STRING_DEFPARM(0))
 124     {
 125       #ifdef WDL_STRING_FASTSUB_DEFINED
 126         int s = str ? str->GetLength() : 0;
 127         if (maxlen>0 && maxlen<s) s=maxlen;
 128
 129         __doSet(0,str?str->Get():NULL,s,0);
 130       #else
 131         Set(str?str->Get():NULL, maxlen); // might be faster: "partial" strlen
 132       #endif
 133     }
 134
 135     void WDL_STRING_FUNCPREFIX Append(const char *str, int maxlen WDL_STRING_DEFPARM(0))
 136     {
 137       int s=0;
 138       if (str)
 139       {
 140         if (maxlen>0) while (s < maxlen && str[s]) s++;
 141         else s=(int)strlen(str);
 142       }
 143
 144       __doSet(GetLength(),str,s,0);
 145     }
 146
 147     void WDL_STRING_FUNCPREFIX Append(const WDL_String *str, int maxlen WDL_STRING_DEFPARM(0))
 148     {
 149       #ifdef WDL_STRING_FASTSUB_DEFINED
 150         int s = str ? str->GetLength() : 0;
 151         if (maxlen>0 && maxlen<s) s=maxlen;
 152
 153         __doSet(GetLength(),str?str->Get():NULL,s,0);
 154       #else
 155         Append(str?str->Get():NULL, maxlen); // might be faster: "partial" strlen
 156       #endif
 157     }
 158
 159     void WDL_STRING_FUNCPREFIX DeleteSub(int position, int len)
 160     {
 161       char *p=(char *)m_hb.Get();
 162       if (!m_hb.GetSize() || !*p) return;
 163       int l=m_hb.GetSize()-1;
 164       if (position < 0 || position >= l) return;
 165       if (position+len > l) len=l-position;
 166       if (len>0)
 167       {
 168         memmove(p+position,p+position+len,l-position-len+1);
 169         m_hb.Resize(l+1-len,false);
 170       }
 171     }
 172
 173     void WDL_STRING_FUNCPREFIX Insert(const char *str, int position, int maxlen WDL_STRING_DEFPARM(0))
 174     {
 175       int ilen=0;
 176       if (str)
 177       {
 178         if (maxlen>0) while (ilen < maxlen && str[ilen]) ilen++;
 179         else ilen=(int)strlen(str);
 180       }
 181
 182       const int srclen = GetLength();
 183       if (position<0) position=0;
 184       else if (position>srclen) position=srclen;
 185       if (ilen>0) __doSet(position,str,ilen,srclen-position);
 186     }
 187
 188     void WDL_STRING_FUNCPREFIX Insert(const WDL_String *str, int position, int maxlen WDL_STRING_DEFPARM(0))
 189     {
 190       #ifdef WDL_STRING_FASTSUB_DEFINED
 191         int ilen = str ? str->GetLength() : 0;
 192         if (maxlen>0 && maxlen<ilen) ilen=maxlen;
 193
 194         const int srclen = m_hb.GetSize()>0 ? m_hb.GetSize()-1 : 0;
 195         if (position<0) position=0;
 196         else if (position>srclen) position=srclen;
 197         if (ilen>0) __doSet(position,str->Get(),ilen,srclen-position);
 198       #else
 199         Insert(str?str->Get():NULL, position, maxlen); // might be faster: "partial" strlen
 200       #endif
 201     }
 202
 203     void WDL_STRING_FUNCPREFIX SetLen(int length, bool resizeDown WDL_STRING_DEFPARM(false))
 204     {
 205       #ifdef WDL_STRING_FASTSUB_DEFINED
 206       const int osz = m_hb.GetSize()>0?m_hb.GetSize()-1:0;
 207       #endif
 208       if (length < 0) length=0;
 209       char *b=(char*)m_hb.Resize(length+1,resizeDown);
 210       if (m_hb.GetSize()==length+1)
 211       {
 212         #ifdef WDL_STRING_FASTSUB_DEFINED
 213           if (length > osz) memset(b+osz,' ',length-osz);
 214         #endif
 215         b[length]=0;
 216       }
 217     }
 218
 219     void WDL_STRING_FUNCPREFIX SetAppendFormattedArgs(bool append, int maxlen, const char* fmt, va_list arglist)
 220     {
 221       int offs = append ? GetLength() : 0;
 222       char* b= (char*) m_hb.Resize(offs+maxlen+1,false)+offs;
 223       if (m_hb.GetSize() != offs+maxlen+1) return;
 224
 225       #ifdef _WIN32
 226         int written = _vsnprintf(b, maxlen+1, fmt, arglist);
 227         if (written < 0 || written>=maxlen) b[written=b[0]?maxlen:0]=0;
 228       #else
 229         int written = vsnprintf(b, maxlen+1, fmt, arglist);
 230         if (written > maxlen) written=maxlen;
 231       #endif
 232
 233       m_hb.Resize(offs + written + 1,false);
 234     }
 235
 236     void WDL_VARARG_WARN(printf,3,4) WDL_STRING_FUNCPREFIX SetFormatted(int maxlen, const char *fmt, ...)
 237     {
 238       va_list arglist;
 239       va_start(arglist, fmt);
 240       SetAppendFormattedArgs(false,maxlen,fmt,arglist);
 241       va_end(arglist);
 242     }
 243
 244     void WDL_VARARG_WARN(printf,3,4) WDL_STRING_FUNCPREFIX AppendFormatted(int maxlen, const char *fmt, ...)
 245     {
 246       va_list arglist;
 247       va_start(arglist, fmt);
 248       SetAppendFormattedArgs(true,maxlen,fmt,arglist);
 249       va_end(arglist);
 250     }
 251
 252     void WDL_STRING_FUNCPREFIX Ellipsize(int minlen, int maxlen)
 253     {
 254       if (maxlen >= 4 && m_hb.GetSize() && GetLength() > maxlen)
 255       {
 256         if (minlen<0) minlen=0;
 257         char *b = (char *)m_hb.Get();
 258         int i;
 259         for (i = maxlen-4; i >= minlen; --i)
 260         {
 261           if (b[i] == ' ')
 262           {
 263             memcpy(b+i, "...",4);
 264             m_hb.Resize(i+4,false);
 265             break;
 266           }
 267         }
 268         if (i < minlen && maxlen >= 4)
 269         {
 270           memcpy(b+maxlen-4, "...",4);
 271           m_hb.Resize(maxlen,false);
 272         }
 273       }
 274     }
 275     const char * WDL_STRING_FUNCPREFIX get_filepart() const // returns whole string if no dir chars
 276     {
 277       const char *p = Get() + GetLength() - 1;
 278       while (p >= Get() && !WDL_IS_DIRCHAR(*p)) --p;
 279       return p + 1;
 280     }
 281     const char * WDL_STRING_FUNCPREFIX get_fileext() const // returns ".ext" or end of string "" if no extension
 282     {
 283       const char *p = Get() + GetLength() - 1;
 284       while (p >= Get() && !WDL_IS_DIRCHAR(*p))
 285       {
 286         if (*p == '.') return p;
 287         --p;
 288       }
 289       return Get() + GetLength();
 290     }
 291     bool WDL_STRING_FUNCPREFIX remove_fileext() // returns true if extension was removed
 292     {
 293       int pos = GetLength() - 1;
 294       while (pos >= 0)
 295       {
 296         char c = Get()[pos];
 297         if (WDL_IS_DIRCHAR(c)) break;
 298         if (c == '.')
 299         {
 300           SetLen(pos);
 301           return true;
 302         }
 303         --pos;
 304       }
 305       return false;
 306     }
 307
 308     char WDL_STRING_FUNCPREFIX remove_filepart(bool keepTrailingSlash WDL_STRING_DEFPARM(false)) // returns directory character used, or 0 if string emptied
 309     {
 310       char rv=0;
 311       int pos = GetLength();
 312       while (pos > 0)
 313       {
 314         char c = Get()[pos];
 315         if (WDL_IS_DIRCHAR(c))
 316         {
 317           rv=c;
 318           if (keepTrailingSlash) ++pos;
 319           break;
 320         }
 321         --pos;
 322       }
 323       SetLen(pos);
 324       return rv;
 325     }
 326
 327     int WDL_STRING_FUNCPREFIX remove_trailing_dirchars() // returns trailing dirchar count removed
 328     {
 329       int cnt = 0;
 330       const int l = GetLength();
 331       while (cnt < l-1)
 332       {
 333         char c = Get()[l - cnt -1];
 334         if (!WDL_IS_DIRCHAR(c)) break;
 335         ++cnt;
 336       }
 337       if (cnt > 0) SetLen(l - cnt);
 338       return cnt;
 339     }
 340 #ifndef WDL_STRING_IMPL_ONLY
 341   private:
 342 #endif
 343     void WDL_STRING_FUNCPREFIX __doSet(int offs, const char *str, int len, int trailkeep)
 344     {
 345       // if non-empty, or (empty and allocated and Set() rather than append/insert), then allow update, otherwise do nothing
 346       if (len==0 && !trailkeep && !offs)
 347       {
 348         #ifdef WDL_STRING_FREE_ON_CLEAR
 349           m_hb.Resize(0,true);
 350         #else
 351           char *p = (char *)m_hb.Resize(1,false);
 352           if (p) *p=0;
 353         #endif
 354       }
 355       else if (len>0 && offs >= 0)
 356       {
 357         const int oldsz = m_hb.GetSize();
 358         const int newsz=offs+len+trailkeep+1;
 359         if (oldsz < newsz)
 360         {
 361           const char *oldb = (const char *)m_hb.Get();
 362           const char *newb = (const char *)m_hb.Resize(newsz,false); // resize up if necessary
 363
 364           // in case str overlaps with input, keep it valid
 365           if (str && newb != oldb && str >= oldb && str < oldb+oldsz) str = newb + (str - oldb);
 366         }
 367
 368         if (m_hb.GetSize() >= newsz)
 369         {
 370           char *newbuf = (char *)m_hb.Get();
 371           if (trailkeep>0) memmove(newbuf+offs+len,newbuf+offs,trailkeep);
 372           if (str) memmove(newbuf+offs,str,len);
 373           newbuf[newsz-1]=0;
 374
 375           // resize down if necessary
 376           if (newsz < oldsz) m_hb.Resize(newsz,false);
 377         }
 378       }
 379     }
 380
 381   #undef WDL_STRING_FUNCPREFIX
 382   #undef WDL_STRING_DEFPARM
 383 #endif // ! WDL_STRING_INTF_ONLY
 384
 385 #ifndef WDL_STRING_IMPL_ONLY
 386
 387   private:
 388     #ifdef WDL_STRING_INTF_ONLY
 389       void __doSet(int offs, const char *str, int len, int trailkeep);
 390     #endif
 391
 392     WDL_HeapBuf m_hb;
 393 };
 394 #endif
 395
 396 #ifndef WDL_STRING_FASTSUB_DEFINED
 397 #undef _WDL_STRING_H_
 398 #define WDL_STRING_FASTSUB_DEFINED
 399 #define WDL_String WDL_FastString
 400 #include "wdlstring.h"
 401 #undef WDL_STRING_FASTSUB_DEFINED
 402 #undef WDL_String
 403 #endif
 404
 405 #endif
 406