libs/splines/util_str.h

   1 /*
   2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 //need to rewrite this
  23
  24 #ifndef __UTIL_STR_H__
  25 #define __UTIL_STR_H__
  26
  27 #include <assert.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30
  31 #ifdef _WIN32
  32 #pragma warning(disable : 4710)     // function 'blah' not inlined
  33 #endif
  34
  35 void TestStringClass ();
  36
  37 class strdata
  38    {
  39    public:
  40       strdata () : len( 0 ), refcount ( 0 ), data ( NULL ), alloced ( 0 ) {}
  41       ~strdata ()
  42          {
  43          if ( data )
  44             delete [] data;
  45          }
  46
  47       void AddRef () { refcount++; }
  48       bool DelRef () // True if killed
  49          {
  50          refcount--;
  51          if ( refcount < 0 )
  52             {
  53             delete this;
  54             return true;
  55             }
  56
  57          return false;
  58          }
  59
  60       int len;
  61       int refcount;
  62       char *data;
  63       int alloced;
  64    };
  65
  66 class idStr {
  67 protected:
  68         strdata *m_data;
  69         void EnsureAlloced ( int, bool keepold = true );
  70         void EnsureDataWritable ();
  71
  72 public:
  73         ~idStr();
  74         idStr();
  75         idStr( const char *text );
  76         idStr( const idStr& string );
  77         idStr( const idStr string, int start, int end );
  78         idStr( const char ch );
  79         idStr( const int num );
  80         idStr( const float num );
  81         idStr( const unsigned num );
  82         int     length( void ) const;
  83         int     allocated( void ) const;
  84         const char * c_str( void ) const;
  85
  86         void            append( const char *text );
  87         void            append( const idStr& text );
  88         char            operator[]( int index ) const;
  89         char&           operator[]( int index );
  90
  91         void            operator=( const idStr& text );
  92         void            operator=( const char *text );
  93
  94         friend  idStr           operator+( const idStr& a, const idStr& b );
  95         friend  idStr           operator+( const idStr& a, const char *b );
  96         friend  idStr           operator+( const char *a, const idStr& b );
  97
  98     friend      idStr           operator+( const idStr& a, const float b );
  99     friend      idStr           operator+( const idStr& a, const int b );
 100     friend      idStr           operator+( const idStr& a, const unsigned b );
 101     friend      idStr           operator+( const idStr& a, const bool b );
 102     friend      idStr           operator+( const idStr& a, const char b );
 103
 104         idStr&          operator+=( const idStr& a );
 105         idStr&          operator+=( const char *a );
 106         idStr&          operator+=( const float a );
 107         idStr&          operator+=( const char a );
 108         idStr&          operator+=( const int a );
 109         idStr&          operator+=( const unsigned a );
 110         idStr&          operator+=( const bool a );
 111
 112         friend  bool            operator==(     const idStr& a, const idStr& b );
 113         friend  bool            operator==(     const idStr& a, const char *b );
 114         friend  bool            operator==(     const char *a, const idStr& b );
 115
 116         friend  bool            operator!=(     const idStr& a, const idStr& b );
 117         friend  bool            operator!=(     const idStr& a, const char *b );
 118         friend  bool            operator!=(     const char *a, const idStr& b );
 119
 120         operator const char * () const;
 121         operator const char * ();
 122
 123     int      icmpn( const char *text, int n ) const;
 124         int      icmpn( const idStr& text, int n ) const;
 125         int      icmp( const char *text ) const;
 126         int      icmp( const idStr& text ) const;
 127         int      cmpn( const char *text, int n ) const;
 128         int      cmpn( const idStr& text, int n ) const;
 129         int      cmp( const char *text ) const;
 130         int      cmp( const idStr& text ) const;
 131
 132         void     tolower( void );
 133         void     toupper( void );
 134
 135         static   char     *tolower( char *s1 );
 136         static   char     *toupper( char *s1 );
 137
 138         static   int      icmpn( const char *s1, const char *s2, int n );
 139         static   int      icmp( const char *s1, const char *s2 );
 140         static   int      cmpn( const char *s1, const char *s2, int n );
 141         static   int      cmp( const char *s1, const char *s2 );
 142
 143         static   void     snprintf ( char *dst, int size, const char *fmt, ... );
 144
 145         static   bool      isNumeric( const char *str );
 146     bool    isNumeric( void ) const;
 147
 148         void     CapLength ( int );
 149
 150         void     BackSlashesToSlashes ();
 151
 152 };
 153
 154 inline idStr::~idStr()
 155         {
 156    if ( m_data )
 157       {
 158       m_data->DelRef ();
 159       m_data = NULL;
 160       }
 161         }
 162
 163 inline idStr::idStr() : m_data ( NULL )
 164         {
 165    EnsureAlloced ( 1 );
 166         m_data->data[ 0 ] = 0;
 167         }
 168
 169 inline idStr::idStr
 170         (
 171         const char *text
 172    ) : m_data ( NULL )
 173
 174         {
 175    int len;
 176
 177         assert( text );
 178
 179         if ( text )
 180                 {
 181       len = strlen( text );
 182                 EnsureAlloced ( len + 1 );
 183                 strcpy( m_data->data, text );
 184       m_data->len = len;
 185                 }
 186         else
 187                 {
 188       EnsureAlloced ( 1 );
 189                 m_data->data[ 0 ] = 0;
 190                 m_data->len = 0;
 191                 }
 192         }
 193
 194 inline idStr::idStr
 195         (
 196         const idStr& text
 197    ) : m_data ( NULL )
 198
 199         {
 200    m_data = text.m_data;
 201    m_data->AddRef ();
 202    }
 203
 204 inline idStr::idStr
 205         (
 206         const idStr text,
 207         int start,
 208         int end
 209    ) : m_data ( NULL )
 210
 211         {
 212         int i;
 213    int len;
 214
 215         if ( end > text.length() )
 216                 {
 217                 end = text.length();
 218                 }
 219
 220         if ( start > text.length() )
 221                 {
 222                 start = text.length();
 223                 }
 224
 225         len = end - start;
 226         if ( len < 0 )
 227                 {
 228                 len = 0;
 229                 }
 230
 231    EnsureAlloced ( len + 1 );
 232
 233         for( i = 0; i < len; i++ )
 234                 {
 235                 m_data->data[ i ] = text[ start + i ];
 236                 }
 237
 238         m_data->data[ len ] = 0;
 239    m_data->len = len;
 240         }
 241
 242 inline idStr::idStr
 243    (
 244    const char ch
 245    ) : m_data ( NULL )
 246
 247    {
 248    EnsureAlloced ( 2 );
 249
 250    m_data->data[ 0 ] = ch;
 251    m_data->data[ 1 ] = 0;
 252    m_data->len = 1;
 253    }
 254
 255 inline idStr::idStr
 256    (
 257    const float num
 258    ) : m_data ( NULL )
 259
 260    {
 261    char text[ 32 ];
 262    int len;
 263
 264    sprintf( text, "%.3f", num );
 265    len = strlen( text );
 266    EnsureAlloced( len + 1 );
 267    strcpy( m_data->data, text );
 268    m_data->len = len;
 269    }
 270
 271 inline idStr::idStr
 272    (
 273    const int num
 274    ) : m_data ( NULL )
 275
 276    {
 277    char text[ 32 ];
 278    int len;
 279
 280    sprintf( text, "%d", num );
 281    len = strlen( text );
 282    EnsureAlloced( len + 1 );
 283    strcpy( m_data->data, text );
 284    m_data->len = len;
 285    }
 286
 287 inline idStr::idStr
 288    (
 289    const unsigned num
 290    ) : m_data ( NULL )
 291
 292    {
 293    char text[ 32 ];
 294    int len;
 295
 296    sprintf( text, "%u", num );
 297    len = strlen( text );
 298    EnsureAlloced( len + 1 );
 299    strcpy( m_data->data, text );
 300    m_data->len = len;
 301    }
 302
 303 inline int idStr::length( void ) const
 304         {
 305    return ( m_data != NULL ) ? m_data->len : 0;
 306         }
 307
 308 inline int idStr::allocated( void ) const
 309         {
 310    return ( m_data != NULL ) ? m_data->alloced + sizeof( *m_data ) : 0;
 311         }
 312
 313 inline const char *idStr::c_str( void ) const
 314         {
 315         assert( m_data );
 316
 317         return m_data->data;
 318         }
 319
 320 inline void idStr::append
 321         (
 322         const char *text
 323         )
 324
 325         {
 326    int len;
 327
 328         assert( text );
 329
 330         if ( text )
 331                 {
 332                 len = length() + strlen( text );
 333                 EnsureAlloced( len + 1 );
 334
 335       strcat( m_data->data, text );
 336       m_data->len = len;
 337                 }
 338         }
 339
 340 inline void idStr::append
 341         (
 342         const idStr& text
 343         )
 344
 345         {
 346    int len;
 347
 348    len = length() + text.length();
 349    EnsureAlloced ( len + 1 );
 350
 351    strcat ( m_data->data, text.c_str () );
 352    m_data->len = len;
 353         }
 354
 355 inline char idStr::operator[]( int index ) const
 356         {
 357    assert ( m_data );
 358
 359    if ( !m_data )
 360       return 0;
 361
 362         // don't include the '/0' in the test, because technically, it's out of bounds
 363         assert( ( index >= 0 ) && ( index < m_data->len ) );
 364
 365         // In release mode, give them a null character
 366         // don't include the '/0' in the test, because technically, it's out of bounds
 367         if ( ( index < 0 ) || ( index >= m_data->len ) )
 368                 {
 369                 return 0;
 370                 }
 371
 372         return m_data->data[ index ];
 373         }
 374
 375 inline char& idStr::operator[]
 376         (
 377         int index
 378         )
 379
 380         {
 381         // Used for result for invalid indices
 382         static char dummy = 0;
 383    assert ( m_data );
 384
 385    // We don't know if they'll write to it or not
 386    // if it's not a const object
 387    EnsureDataWritable ();
 388
 389    if ( !m_data )
 390       return dummy;
 391
 392         // don't include the '/0' in the test, because technically, it's out of bounds
 393         assert( ( index >= 0 ) && ( index < m_data->len ) );
 394
 395         // In release mode, let them change a safe variable
 396         // don't include the '/0' in the test, because technically, it's out of bounds
 397         if ( ( index < 0 ) || ( index >= m_data->len ) )
 398                 {
 399                 return dummy;
 400                 }
 401
 402         return m_data->data[ index ];
 403         }
 404
 405 inline void idStr::operator=
 406         (
 407         const idStr& text
 408         )
 409
 410         {
 411    // adding the reference before deleting our current reference prevents
 412    // us from deleting our string if we are copying from ourself
 413    text.m_data->AddRef();
 414    m_data->DelRef();
 415    m_data = text.m_data;
 416    }
 417
 418 inline void idStr::operator=
 419         (
 420         const char *text
 421         )
 422
 423         {
 424    int len;
 425
 426         assert( text );
 427
 428         if ( !text )
 429                 {
 430                 // safe behaviour if NULL
 431                 EnsureAlloced ( 1, false );
 432       m_data->data[0] = 0;
 433       m_data->len = 0;
 434       return;
 435                 }
 436
 437    if ( !m_data )
 438       {
 439       len = strlen ( text );
 440       EnsureAlloced( len + 1, false );
 441       strcpy ( m_data->data, text );
 442       m_data->len = len;
 443       return;
 444       }
 445
 446    if ( text == m_data->data )
 447       return; // Copying same thing.  Punt.
 448
 449    // If we alias and I don't do this, I could corrupt other strings...  This
 450    // will get called with EnsureAlloced anyway
 451    EnsureDataWritable ();
 452
 453    // Now we need to check if we're aliasing..
 454    if ( text >= m_data->data && text <= m_data->data + m_data->len )
 455       {
 456       // Great, we're aliasing.  We're copying from inside ourselves.
 457       // This means that I don't have to ensure that anything is alloced,
 458       // though I'll assert just in case.
 459       int diff = text - m_data->data;
 460       int i;
 461
 462       assert ( strlen ( text ) < (unsigned) m_data->len );
 463
 464       for ( i = 0; text[i]; i++ )
 465          {
 466          m_data->data[i] = text[i];
 467          }
 468
 469       m_data->data[i] = 0;
 470
 471       m_data->len -= diff;
 472
 473       return;
 474       }
 475
 476         len = strlen( text );
 477    EnsureAlloced ( len + 1, false );
 478         strcpy( m_data->data, text );
 479    m_data->len = len;
 480         }
 481
 482 inline idStr operator+
 483         (
 484         const idStr& a,
 485         const idStr& b
 486         )
 487
 488         {
 489         idStr result( a );
 490
 491         result.append( b );
 492
 493         return result;
 494         }
 495
 496 inline idStr operator+
 497         (
 498         const idStr& a,
 499         const char *b
 500         )
 501
 502         {
 503         idStr result( a );
 504
 505         result.append( b );
 506
 507         return result;
 508         }
 509
 510 inline idStr operator+
 511         (
 512         const char *a,
 513         const idStr& b
 514         )
 515
 516         {
 517         idStr result( a );
 518
 519         result.append( b );
 520
 521         return result;
 522         }
 523
 524 inline idStr operator+
 525    (
 526    const idStr& a,
 527    const bool b
 528    )
 529
 530    {
 531         idStr result( a );
 532
 533    result.append( b ? "true" : "false" );
 534
 535         return result;
 536    }
 537
 538 inline idStr operator+
 539         (
 540    const idStr& a,
 541         const char b
 542         )
 543
 544         {
 545    char text[ 2 ];
 546
 547    text[ 0 ] = b;
 548    text[ 1 ] = 0;
 549
 550         return a + text;
 551         }
 552
 553 inline idStr& idStr::operator+=
 554         (
 555         const idStr& a
 556         )
 557
 558         {
 559         append( a );
 560         return *this;
 561         }
 562
 563 inline idStr& idStr::operator+=
 564         (
 565         const char *a
 566         )
 567
 568         {
 569         append( a );
 570         return *this;
 571         }
 572
 573 inline idStr& idStr::operator+=
 574         (
 575         const char a
 576         )
 577
 578         {
 579    char text[ 2 ];
 580
 581    text[ 0 ] = a;
 582    text[ 1 ] = 0;
 583         append( text );
 584
 585    return *this;
 586         }
 587
 588 inline idStr& idStr::operator+=
 589         (
 590         const bool a
 591         )
 592
 593         {
 594    append( a ? "true" : "false" );
 595         return *this;
 596         }
 597
 598 inline bool operator==
 599         (
 600         const idStr& a,
 601         const idStr& b
 602         )
 603
 604         {
 605         return ( !strcmp( a.c_str(), b.c_str() ) );
 606         }
 607
 608 inline bool operator==
 609         (
 610         const idStr& a,
 611         const char *b
 612         )
 613
 614         {
 615         assert( b );
 616         if ( !b )
 617                 {
 618                 return false;
 619                 }
 620         return ( !strcmp( a.c_str(), b ) );
 621         }
 622
 623 inline bool operator==
 624         (
 625         const char *a,
 626         const idStr& b
 627         )
 628
 629         {
 630         assert( a );
 631         if ( !a )
 632                 {
 633                 return false;
 634                 }
 635         return ( !strcmp( a, b.c_str() ) );
 636         }
 637
 638 inline bool operator!=
 639         (
 640         const idStr& a,
 641         const idStr& b
 642         )
 643
 644         {
 645         return !( a == b );
 646         }
 647
 648 inline bool operator!=
 649         (
 650         const idStr& a,
 651         const char *b
 652         )
 653
 654         {
 655         return !( a == b );
 656         }
 657
 658 inline bool operator!=
 659         (
 660         const char *a,
 661         const idStr& b
 662         )
 663
 664         {
 665         return !( a == b );
 666         }
 667
 668 inline int idStr::icmpn
 669    (
 670    const char *text,
 671    int n
 672    ) const
 673
 674    {
 675         assert( m_data );
 676         assert( text );
 677
 678    return idStr::icmpn( m_data->data, text, n );
 679    }
 680
 681 inline int idStr::icmpn
 682    (
 683    const idStr& text,
 684    int n
 685    ) const
 686
 687    {
 688         assert( m_data );
 689         assert( text.m_data );
 690
 691    return idStr::icmpn( m_data->data, text.m_data->data, n );
 692    }
 693
 694 inline int idStr::icmp
 695    (
 696    const char *text
 697    ) const
 698
 699    {
 700         assert( m_data );
 701         assert( text );
 702
 703    return idStr::icmp( m_data->data, text );
 704    }
 705
 706 inline int idStr::icmp
 707    (
 708    const idStr& text
 709    ) const
 710
 711    {
 712         assert( c_str () );
 713         assert( text.c_str () );
 714
 715    return idStr::icmp( c_str () , text.c_str () );
 716    }
 717
 718 inline int idStr::cmp
 719    (
 720    const char *text
 721    ) const
 722
 723    {
 724         assert( m_data );
 725         assert( text );
 726
 727    return idStr::cmp( m_data->data, text );
 728    }
 729
 730 inline int idStr::cmp
 731    (
 732    const idStr& text
 733    ) const
 734
 735    {
 736         assert( c_str () );
 737         assert( text.c_str () );
 738
 739    return idStr::cmp( c_str () , text.c_str () );
 740    }
 741
 742 inline int idStr::cmpn
 743    (
 744    const char *text,
 745    int n
 746    ) const
 747
 748    {
 749         assert( c_str () );
 750         assert( text );
 751
 752    return idStr::cmpn( c_str () , text, n );
 753    }
 754
 755 inline int idStr::cmpn
 756    (
 757    const idStr& text,
 758    int n
 759    ) const
 760
 761    {
 762         assert( c_str () );
 763         assert( text.c_str ()  );
 764
 765    return idStr::cmpn( c_str () , text.c_str () , n );
 766    }
 767
 768 inline void idStr::tolower
 769    (
 770    void
 771    )
 772
 773    {
 774    assert( m_data );
 775
 776    EnsureDataWritable ();
 777
 778    idStr::tolower( m_data->data );
 779    }
 780
 781 inline void idStr::toupper
 782    (
 783    void
 784    )
 785
 786    {
 787    assert( m_data );
 788
 789    EnsureDataWritable ();
 790
 791    idStr::toupper( m_data->data );
 792    }
 793
 794 inline bool idStr::isNumeric
 795    (
 796    void
 797    ) const
 798
 799    {
 800    assert( m_data );
 801    return idStr::isNumeric( m_data->data );
 802    }
 803
 804 inline idStr::operator const char *() {
 805         return c_str();
 806 }
 807
 808 inline idStr::operator const char *
 809    (
 810    void
 811    ) const
 812
 813    {
 814    return c_str ();
 815    }
 816
 817 #endif