~swag/armagetronad/0.2.9-sty+ct+ap-fork

« back to all changes in this revision

Viewing changes to src/tools/tString.cpp

  • Committer: SwagTron
  • Date: 2019-08-06 02:52:56 UTC
  • Revision ID: swagtron-20190806025256-8sruhpbirsa67du8
Planned to wait until I could think of a better way to code /rgb, but I have been asked to add the ability to save and load several times.
Edited /rgb
Current Usuage:
       /rgb with no parameters displays current rgb.
       /rgb 15 3 3 will set player 1's RGB to R15 G3 B3.
       /rgb unique gives all players unique colors.
       /rgb random gives all players random colors.
       /rgb 2 15 3 3 Will change player 2's colors to 15 3 3.
       /rgb save will save your current colors to var/colors.txt
       /rgb save player will save the players current colors to var/colors.txt
       /rgb list will list your current saved colors from var/colors.txt.
       /rgb load 1 will load from line #1 in the list.
       /rgb clear will clear your current list of saved colors.
       /rgb help displays the usuage in-game.
Added RGB_COLORS_FILE which can be configured to change the name of the colors.txt file to another name within /var/ where user.cfg is. This can be used to use new files when your old list is full.
Also made a lot of the text use english_base.txt

Currently no preview other than converting the r,g,b values into a color string or using the color code already in colors.txt. Hopefully I could add a mutli-colored tail preview.

Added ReplaceWhitespace to tString for /rgb.

Also edited the style of other commands (/colors).

Show diffs side-by-side

added added

removed removed

Lines of Context:
429
429
    return true;
430
430
}
431
431
 
432
 
// *******************************************************************************
433
 
// *
434
 
// *    StrPos
435
 
// *
436
 
// *******************************************************************************
437
 
//!
438
 
//!             @param  tofind  the string to find
439
 
//!             @return             position of the start of the string or negative if not found
440
 
//!
441
 
// *******************************************************************************
442
 
 
443
 
int tString::StrPos( const tString & tofind ) const
444
 
{
445
 
    if (tofind.Len() > Len()) {
446
 
        return -1;
447
 
    }
448
 
    for (int i=0; i<Len()-1; i++) {
449
 
        if ((*this)(i) == tofind(0)) {
450
 
            bool found = true;
451
 
            for (int j=0; j<tofind.Len()-1 && i+j < Len()-1; j++) {
452
 
                if ((*this)(i+j) != tofind(j))
453
 
                    found = false;
454
 
            }
455
 
            if (found == true)
456
 
                return i;
457
 
        }
458
 
    }
459
 
 
460
 
    return -1;
461
 
}
462
 
 
463
 
int tString::StrPos( int start, const tString & tofind ) const
464
 
{
465
 
    if (tofind.Len() > Len()) {
466
 
        return -1;
467
 
    }
468
 
    for (int i = start; i<Len()-1; i++) {
469
 
        if ((*this)(i) == tofind(0)) {
470
 
            bool found = true;
471
 
            for (int j=0; j<tofind.Len()-1; j++) {
472
 
                if ((*this)(i+j) != tofind(j))
473
 
                    found = false;
474
 
            }
475
 
            if (found == true)
476
 
                return i;
477
 
        }
478
 
    }
479
 
 
480
 
    return -1;
481
 
}
482
 
 
483
 
// *******************************************************************************
484
 
// *
485
 
// *    StrPos
486
 
// *
487
 
// *******************************************************************************
488
 
//!
489
 
//!             @param  tofind  the string to find
490
 
//!             @return             position of the start of the string or negative if not found
491
 
//!
492
 
// *******************************************************************************
493
 
 
494
 
int tString::StrPos( const char * tofind ) const
495
 
{
496
 
    return StrPos( tString ( tofind ) );
497
 
}
498
 
 
499
 
int tString::StrPos( int start, const char * tofind ) const
500
 
{
501
 
    return StrPos( start, tString ( tofind ) );
502
 
}
 
432
// *******************************************************************************
 
433
// *
 
434
// *    StrPos
 
435
// *
 
436
// *******************************************************************************
 
437
//!
 
438
//!             @param  tofind  the string to find
 
439
//!             @return             position of the start of the string or negative if not found
 
440
//!
 
441
// *******************************************************************************
 
442
 
 
443
int tString::StrPos( const tString & tofind ) const
 
444
{
 
445
    if (tofind.Len() > Len()) {
 
446
        return -1;
 
447
    }
 
448
    for (int i=0; i<Len()-1; i++) {
 
449
        if ((*this)(i) == tofind(0)) {
 
450
            bool found = true;
 
451
            for (int j=0; j<tofind.Len()-1 && i+j < Len()-1; j++) {
 
452
                if ((*this)(i+j) != tofind(j))
 
453
                    found = false;
 
454
            }
 
455
            if (found == true)
 
456
                return i;
 
457
        }
 
458
    }
 
459
 
 
460
    return -1;
 
461
}
 
462
 
 
463
int tString::StrPos( int start, const tString & tofind ) const
 
464
{
 
465
    if (tofind.Len() > Len()) {
 
466
        return -1;
 
467
    }
 
468
    for (int i = start; i<Len()-1; i++) {
 
469
        if ((*this)(i) == tofind(0)) {
 
470
            bool found = true;
 
471
            for (int j=0; j<tofind.Len()-1; j++) {
 
472
                if ((*this)(i+j) != tofind(j))
 
473
                    found = false;
 
474
            }
 
475
            if (found == true)
 
476
                return i;
 
477
        }
 
478
    }
 
479
 
 
480
    return -1;
 
481
}
 
482
 
 
483
// *******************************************************************************
 
484
// *
 
485
// *    StrPos
 
486
// *
 
487
// *******************************************************************************
 
488
//!
 
489
//!             @param  tofind  the string to find
 
490
//!             @return             position of the start of the string or negative if not found
 
491
//!
 
492
// *******************************************************************************
 
493
 
 
494
int tString::StrPos( const char * tofind ) const
 
495
{
 
496
    return StrPos( tString ( tofind ) );
 
497
}
 
498
 
 
499
int tString::StrPos( int start, const char * tofind ) const
 
500
{
 
501
    return StrPos( start, tString ( tofind ) );
 
502
}
503
503
 
504
504
tString tString::SubStr( const int start, int len) const
505
505
{
548
548
 
549
549
int tString::toInt() const {
550
550
    return toInt(0);
551
 
}
 
551
}
552
552
 
553
553
// *******************************************************************************************
554
554
// *
564
564
bool tString::StartsWith( const char * other ) const
565
565
{
566
566
    return StartsWith( tString( other ) );
567
 
}
568
 
 
569
 
// *******************************************************************************************
570
 
// *
571
 
// *   EndsWith
572
 
// *
573
 
// *******************************************************************************************
574
 
//!
575
 
//!        @param  other  the string to compare the end with
576
 
//!        @return        true if this ends with other
577
 
//!
578
 
// *******************************************************************************************
579
 
 
580
 
bool tString::EndsWith(const tString & other ) const
581
 
{
582
 
    if (other.Len() > Len()) {
583
 
        return false;
584
 
    }
585
 
    tString thisString = Reverse();
586
 
    tString otherString(other);
587
 
    otherString = otherString.Reverse();
588
 
 
589
 
    // Haha, just use StartsWith to do the comparison :)
590
 
    return thisString.StartsWith(otherString);
591
 
    //return true;
592
 
}
593
 
 
594
 
// *******************************************************************************************
595
 
//!
596
 
//!        @param  other  the string to compare the end with
597
 
//!        @return        true if this ends with other
598
 
//!
599
 
// *******************************************************************************************
600
 
 
601
 
bool tString::EndsWith( const char* other) const {
602
 
    return EndsWith( tString(other) );
 
567
}
 
568
 
 
569
// *******************************************************************************************
 
570
// *
 
571
// *   EndsWith
 
572
// *
 
573
// *******************************************************************************************
 
574
//!
 
575
//!        @param  other  the string to compare the end with
 
576
//!        @return        true if this ends with other
 
577
//!
 
578
// *******************************************************************************************
 
579
 
 
580
bool tString::EndsWith(const tString & other ) const
 
581
{
 
582
    if (other.Len() > Len()) {
 
583
        return false;
 
584
    }
 
585
    tString thisString = Reverse();
 
586
    tString otherString(other);
 
587
    otherString = otherString.Reverse();
 
588
 
 
589
    // Haha, just use StartsWith to do the comparison :)
 
590
    return thisString.StartsWith(otherString);
 
591
    //return true;
 
592
}
 
593
 
 
594
// *******************************************************************************************
 
595
//!
 
596
//!        @param  other  the string to compare the end with
 
597
//!        @return        true if this ends with other
 
598
//!
 
599
// *******************************************************************************************
 
600
 
 
601
bool tString::EndsWith( const char* other) const {
 
602
    return EndsWith( tString(other) );
603
603
}
604
604
 
605
605
/*
1199
1199
{
1200
1200
    tString::operator = ( s );
1201
1201
    return *this;
1202
 
}
1203
 
 
 
1202
}
 
1203
 
1204
1204
// *******************************************************************************************
1205
1205
// *
1206
1206
// *    HasColors
1210
1210
//!             @param  c       C style string or tString to clear of color codes
1211
1211
//!             @return         false/true - if colors (do not) exist
1212
1212
//!
1213
 
// *******************************************************************************************
1214
 
 
1215
 
bool tColoredString::HasColors( const char *c )
1216
 
{
1217
 
    int len = strlen(c);
1218
 
 
 
1213
// *******************************************************************************************
 
1214
 
 
1215
bool tColoredString::HasColors( const char *c )
 
1216
{
 
1217
    int len = strlen(c);
 
1218
 
1219
1219
    // walk through string
1220
 
    while (*c!='\0')
 
1220
    while (*c!='\0')
1221
1221
    {
1222
1222
        // skip color codes
1223
1223
        if (*c=='0' && len >= 2 && c[1]=='x')
1225
1225
            return true;
1226
1226
        }
1227
1227
        else
1228
 
        {
 
1228
        {
1229
1229
            c++;
1230
1230
            len--;
1231
1231
        }
1232
 
    }
1233
 
 
1234
 
    return false;
 
1232
    }
 
1233
 
 
1234
    return false;
1235
1235
}
1236
 
 
 
1236
 
1237
1237
// *******************************************************************************************
1238
1238
// *
1239
1239
// *    HasColors
1243
1243
//!             @param  c       C style string or tString to clear of color codes
1244
1244
//!             @return         string with lower cased color codes
1245
1245
//!
1246
 
// *******************************************************************************************
1247
 
 
1248
 
tString tColoredString::LowerColors( const char *c )
1249
 
{
1250
 
    tString ret;
1251
 
    int len = strlen(c);
1252
 
 
 
1246
// *******************************************************************************************
 
1247
 
 
1248
tString tColoredString::LowerColors( const char *c )
 
1249
{
 
1250
    tString ret;
 
1251
    int len = strlen(c);
 
1252
 
1253
1253
    // walk through string
1254
 
    while (*c!='\0')
 
1254
    while (*c!='\0')
1255
1255
    {
1256
1256
        // skip color codes
1257
1257
        if (*c=='0' && len >= 2 && c[1]=='x')
1258
 
        {
1259
 
            tString color_code;
1260
 
            color_code << c[0] << c[1] << c[2] << c[3] << c[4] << c[5] << c[6] << c[7];
1261
 
            if (color_code == "0xRESETT")
1262
 
                ret << color_code;
1263
 
            else
1264
 
                ret << color_code.ToLower();
1265
 
 
 
1258
        {
 
1259
            tString color_code;
 
1260
            color_code << c[0] << c[1] << c[2] << c[3] << c[4] << c[5] << c[6] << c[7];
 
1261
            if (color_code == "0xRESETT")
 
1262
                ret << color_code;
 
1263
            else
 
1264
                ret << color_code.ToLower();
 
1265
 
1266
1266
            c   += 8;
1267
1267
            len -= 8;
1268
1268
        }
1269
1269
        else
1270
 
        {
 
1270
        {
1271
1271
            ret << (*(c++));
1272
1272
            len--;
1273
1273
        }
1274
 
    }
1275
 
 
1276
 
    return ret;
1277
 
}
 
1274
    }
 
1275
 
 
1276
    return ret;
 
1277
}
1278
1278
 
1279
1279
// *******************************************************************************************
1280
1280
// *
1434
1434
public:
1435
1435
    tCharacterFilter()
1436
1436
    {
1437
 
        int i;
1438
 
        filter[0]=0;
1439
 
 
1440
 
        // map all unknown characters to underscores
1441
 
        for (i=255; i>=0; --i)
1442
 
        {
1443
 
            filter[i] = '_';
1444
 
        }
1445
 
 
1446
 
        // leave ASCII characters as they are
1447
 
        // for (i=127; i>=32; --i)
1448
 
        // no, leave all visible ISO Latin 1 characters as they are
1449
 
        for ( i = 32; i <= 126; ++i )
1450
 
            filter[ i ] = i;
1451
 
        for ( i = 161; i <= 255; ++i )
1452
 
            filter[ i ] = i;
1453
 
 
1454
 
        filter[ 160 ] = ' '; // non-breaking space
1455
 
 
1456
 
        // map return and tab to space
1457
 
        SetMap('\n',' ');
1458
 
        SetMap('\t',' ');
1459
 
 
1460
 
        //! map umlauts and stuff to their base characters
1461
 
        /*
1462
 
        SetMap(0xc0,0xc5,'A');
1463
 
        SetMap(0xd1,0xd6,'O');
1464
 
        SetMap(0xd9,0xdD,'U');
1465
 
        SetMap(0xdf,'s');
1466
 
        SetMap(0xe0,0xe5,'a');
1467
 
        SetMap(0xe8,0xeb,'e');
1468
 
        SetMap(0xec,0xef,'i');
1469
 
        SetMap(0xf0,0xf6,'o');
1470
 
        SetMap(0xf9,0xfc,'u');
1471
 
        */
1472
 
 
1473
 
        //!todo: map weird chars
1474
 
        // make this data driven.
1475
 
    }
1476
 
 
1477
 
    char Filter( unsigned char in )
1478
 
    {
1479
 
        return filter[ static_cast< unsigned int >( in )];
1480
 
    }
1481
 
private:
1482
 
    void SetMap( int in1, int in2, unsigned char out)
1483
 
    {
1484
 
        tASSERT( in2 <= 0xff );
1485
 
        tASSERT( 0 <= in1 );
1486
 
        tASSERT( in1 < in2 );
1487
 
        for( int i = in2; i >= in1; --i )
1488
 
            filter[ i ] = out;
1489
 
    }
1490
 
 
1491
 
    void SetMap( unsigned char in, unsigned char out)
1492
 
    {
1493
 
        filter[ static_cast< unsigned int >( in ) ] = out;
1494
 
    }
1495
 
 
1496
 
    char filter[256];
 
1437
        int i;
 
1438
        filter[0]=0;
 
1439
 
 
1440
        // map all unknown characters to underscores
 
1441
        for (i=255; i>=0; --i)
 
1442
        {
 
1443
            filter[i] = '_';
 
1444
        }
 
1445
 
 
1446
        // leave ASCII characters as they are
 
1447
        // for (i=127; i>=32; --i)
 
1448
        // no, leave all visible ISO Latin 1 characters as they are
 
1449
        for ( i = 32; i <= 126; ++i )
 
1450
            filter[ i ] = i;
 
1451
        for ( i = 161; i <= 255; ++i )
 
1452
            filter[ i ] = i;
 
1453
 
 
1454
        filter[ 160 ] = ' '; // non-breaking space
 
1455
 
 
1456
        // map return and tab to space
 
1457
        SetMap('\n',' ');
 
1458
        SetMap('\t',' ');
 
1459
 
 
1460
        //! map umlauts and stuff to their base characters
 
1461
        /*
 
1462
        SetMap(0xc0,0xc5,'A');
 
1463
        SetMap(0xd1,0xd6,'O');
 
1464
        SetMap(0xd9,0xdD,'U');
 
1465
        SetMap(0xdf,'s');
 
1466
        SetMap(0xe0,0xe5,'a');
 
1467
        SetMap(0xe8,0xeb,'e');
 
1468
        SetMap(0xec,0xef,'i');
 
1469
        SetMap(0xf0,0xf6,'o');
 
1470
        SetMap(0xf9,0xfc,'u');
 
1471
        */
 
1472
 
 
1473
        //!todo: map weird chars
 
1474
        // make this data driven.
 
1475
    }
 
1476
 
 
1477
    char Filter( unsigned char in )
 
1478
    {
 
1479
        return filter[ static_cast< unsigned int >( in )];
 
1480
    }
 
1481
private:
 
1482
    void SetMap( int in1, int in2, unsigned char out)
 
1483
    {
 
1484
        tASSERT( in2 <= 0xff );
 
1485
        tASSERT( 0 <= in1 );
 
1486
        tASSERT( in1 < in2 );
 
1487
        for( int i = in2; i >= in1; --i )
 
1488
            filter[ i ] = out;
 
1489
    }
 
1490
 
 
1491
    void SetMap( unsigned char in, unsigned char out)
 
1492
    {
 
1493
        filter[ static_cast< unsigned int >( in ) ] = out;
 
1494
    }
 
1495
 
 
1496
    char filter[256];
1497
1497
};
1498
1498
 
1499
1499
// *******************************************************************************************
1644
1644
            toReturn << (*this)(i);
1645
1645
    }
1646
1646
    return toReturn;
1647
 
}
1648
 
 
1649
 
//! @return a string where all characters are converted to lowercase. "Hello World!" -> "hello world!"
1650
 
tString tString::ToLower(void) const
1651
 
{
1652
 
    tString ret(*this);
 
1647
}
 
1648
 
 
1649
// *******************************************************************************************
 
1650
// *
 
1651
// *    ReplaceWhitespace
 
1652
// *
 
1653
// *******************************************************************************************
 
1654
//!
 
1655
//!    @return     a string with all whitespace removed. "hi everyone " -> "hi_everyone"
 
1656
//!
 
1657
// *******************************************************************************************
 
1658
 
 
1659
 
 
1660
tString tString::ReplaceWhitespace( void ) const
 
1661
{
 
1662
    tString toReturn;
 
1663
 
 
1664
    for( int i = 0; i<=Len()-2; i++ )
 
1665
    {
 
1666
        if( isblank((*this)(i)) )
 
1667
        {
 
1668
            toReturn << "_";
 
1669
        }
 
1670
            else
 
1671
            {
 
1672
            toReturn << (*this)(i);
 
1673
           }
 
1674
    }
 
1675
    return toReturn;
 
1676
}
 
1677
 
 
1678
//! @return a string where all characters are converted to lowercase. "Hello World!" -> "hello world!"
 
1679
tString tString::ToLower(void) const
 
1680
{
 
1681
    tString ret(*this);
1653
1682
    for( int i = ret.Len()-2; i >= 0; --i )
1654
1683
    {
1655
1684
        ret[i] = tolower( ret[i] );
1656
 
    }
1657
 
    return ret;
1658
 
}
1659
 
 
1660
 
//! @return a string where all characters are converted to uppercase. "Hello World!" -> "HELLO WORLD!"
1661
 
tString tString::ToUpper(void) const
1662
 
{
1663
 
    tString ret(*this);
 
1685
    }
 
1686
    return ret;
 
1687
}
 
1688
 
 
1689
//! @return a string where all characters are converted to uppercase. "Hello World!" -> "HELLO WORLD!"
 
1690
tString tString::ToUpper(void) const
 
1691
{
 
1692
    tString ret(*this);
1664
1693
    for( int i = ret.Len()-2; i >= 0; --i )
1665
1694
    {
1666
1695
        ret[i] = toupper( ret[i] );
1667
 
    }
1668
 
    return ret;
1669
 
}
1670
 
 
1671
 
//  filtering all strings
1672
 
class tStringFilter
1673
 
{
1674
 
public:
1675
 
    tStringFilter()
1676
 
    {
1677
 
        int i;
1678
 
        filter[0]=0;
1679
 
 
1680
 
        // map all unknown characters to underscores
1681
 
        for (i=255; i>0; --i)
1682
 
        {
1683
 
            filter[i] = '_';
1684
 
        }
1685
 
 
1686
 
        // leave ASCII characters as they are
1687
 
        for (i=126; i>32; --i)
1688
 
        {
1689
 
            filter[i] = i;
1690
 
        }
1691
 
 
1692
 
        // but convert uppercase characters to lowercase
1693
 
        for (i='Z'; i>='A'; --i)
1694
 
        {
1695
 
            filter[i] = i + ('a' - 'A');
1696
 
        }
1697
 
 
1698
 
        //! map umlauts and stuff to their base characters
1699
 
        SetMap(0xc0,0xc5,'a');
1700
 
        SetMap(0xd1,0xd6,'o');
1701
 
        SetMap(0xd9,0xdD,'u');
1702
 
        SetMap(0xdf,'s');
1703
 
        SetMap(0xe0,0xe5,'a');
1704
 
        SetMap(0xe8,0xeb,'e');
1705
 
        SetMap(0xec,0xef,'i');
1706
 
        SetMap(0xf0,0xf6,'o');
1707
 
        SetMap(0xf9,0xfc,'u');
1708
 
 
1709
 
        // ok, some of those are a bit questionable, but still better than _...
1710
 
        SetMap(161,'!');
1711
 
        SetMap(162,'c');
1712
 
        SetMap(163,'l');
1713
 
        SetMap(165,'y');
1714
 
        SetMap(166,'|');
1715
 
        SetMap(167,'s');
1716
 
        SetMap(168,'"');
1717
 
        SetMap(169,'c');
1718
 
        SetMap(170,'a');
1719
 
        SetMap(171,'"');
1720
 
        SetMap(172,'!');
1721
 
        SetMap(174,'r');
1722
 
        SetMap(176,'o');
1723
 
        SetMap(177,'+');
1724
 
        SetMap(178,'2');
1725
 
        SetMap(179,'3');
1726
 
        SetMap(182,'p');
1727
 
        SetMap(183,'.');
1728
 
        SetMap(185,'1');
1729
 
        SetMap(187,'"');
1730
 
        SetMap(198,'a');
1731
 
        SetMap(199,'c');
1732
 
        SetMap(208,'d');
1733
 
        SetMap(209,'n');
1734
 
        SetMap(215,'x');
1735
 
        SetMap(216,'o');
1736
 
        SetMap(221,'y');
1737
 
        SetMap(222,'p');
1738
 
        SetMap(231,'c');
1739
 
        SetMap(241,'n');
1740
 
        SetMap(247,'/');
1741
 
        SetMap(248,'o');
1742
 
        SetMap(253,'y');
1743
 
        SetMap(254,'p');
1744
 
        SetMap(255,'y');
1745
 
 
1746
 
        //map 0 to o because they look similar
1747
 
        SetMap('0','o');
1748
 
 
1749
 
        // TODO: make this data driven.
1750
 
    }
1751
 
 
1752
 
    char Filter( unsigned char in )
1753
 
    {
1754
 
        return filter[ static_cast< unsigned int >( in )];
1755
 
    }
1756
 
private:
1757
 
    void SetMap( int in1, int in2, unsigned char out)
1758
 
    {
1759
 
        tASSERT( in2 <= 0xff );
1760
 
        tASSERT( 0 <= in1 );
1761
 
        tASSERT( in1 < in2 );
1762
 
        for( int i = in2; i >= in1; --i )
1763
 
            filter[ i ] = out;
1764
 
    }
1765
 
 
1766
 
    void SetMap( unsigned char in, unsigned char out)
1767
 
    {
1768
 
        filter[ static_cast< unsigned int >( in ) ] = out;
1769
 
    }
1770
 
 
1771
 
    char filter[256];
1772
 
};
1773
 
 
1774
 
static bool st_IsUnderscore( char c )
1775
 
{
1776
 
    return c == '_';
1777
 
}
1778
 
 
1779
 
// function prototype for character testing functions
1780
 
typedef bool TestSCharacter( char c );
1781
 
 
1782
 
// strips characters matching a test beginnings and ends of names
1783
 
static void st_StripMatchingEnds( tString & stripper, TestSCharacter & beginTester, TestSCharacter & endTester)
1784
 
{
1785
 
    int len = stripper.Len() - 1;
1786
 
    int first = 0, last = len;
1787
 
 
1788
 
    // eat whitespace from beginnig and end
1789
 
    while ( first < len && beginTester( stripper[first] ) ) ++first;
1790
 
    while ( last > 0 && ( !stripper[last] || endTester(stripper[last] ) ) ) --last;
1791
 
 
1792
 
    // strip everything?
1793
 
    if ( first > last )
1794
 
    {
1795
 
        stripper = "";
1796
 
        return;
1797
 
    }
1798
 
 
1799
 
    // strip
1800
 
    if ( first > 0 || last < stripper.Len() - 1 )
1801
 
        stripper = stripper.SubStr( first, last + 1 - first );
1802
 
}
1803
 
 
 
1696
    }
 
1697
    return ret;
 
1698
}
 
1699
 
 
1700
//  filtering all strings
 
1701
class tStringFilter
 
1702
{
 
1703
public:
 
1704
    tStringFilter()
 
1705
    {
 
1706
        int i;
 
1707
        filter[0]=0;
 
1708
 
 
1709
        // map all unknown characters to underscores
 
1710
        for (i=255; i>0; --i)
 
1711
        {
 
1712
            filter[i] = '_';
 
1713
        }
 
1714
 
 
1715
        // leave ASCII characters as they are
 
1716
        for (i=126; i>32; --i)
 
1717
        {
 
1718
            filter[i] = i;
 
1719
        }
 
1720
 
 
1721
        // but convert uppercase characters to lowercase
 
1722
        for (i='Z'; i>='A'; --i)
 
1723
        {
 
1724
            filter[i] = i + ('a' - 'A');
 
1725
        }
 
1726
 
 
1727
        //! map umlauts and stuff to their base characters
 
1728
        SetMap(0xc0,0xc5,'a');
 
1729
        SetMap(0xd1,0xd6,'o');
 
1730
        SetMap(0xd9,0xdD,'u');
 
1731
        SetMap(0xdf,'s');
 
1732
        SetMap(0xe0,0xe5,'a');
 
1733
        SetMap(0xe8,0xeb,'e');
 
1734
        SetMap(0xec,0xef,'i');
 
1735
        SetMap(0xf0,0xf6,'o');
 
1736
        SetMap(0xf9,0xfc,'u');
 
1737
 
 
1738
        // ok, some of those are a bit questionable, but still better than _...
 
1739
        SetMap(161,'!');
 
1740
        SetMap(162,'c');
 
1741
        SetMap(163,'l');
 
1742
        SetMap(165,'y');
 
1743
        SetMap(166,'|');
 
1744
        SetMap(167,'s');
 
1745
        SetMap(168,'"');
 
1746
        SetMap(169,'c');
 
1747
        SetMap(170,'a');
 
1748
        SetMap(171,'"');
 
1749
        SetMap(172,'!');
 
1750
        SetMap(174,'r');
 
1751
        SetMap(176,'o');
 
1752
        SetMap(177,'+');
 
1753
        SetMap(178,'2');
 
1754
        SetMap(179,'3');
 
1755
        SetMap(182,'p');
 
1756
        SetMap(183,'.');
 
1757
        SetMap(185,'1');
 
1758
        SetMap(187,'"');
 
1759
        SetMap(198,'a');
 
1760
        SetMap(199,'c');
 
1761
        SetMap(208,'d');
 
1762
        SetMap(209,'n');
 
1763
        SetMap(215,'x');
 
1764
        SetMap(216,'o');
 
1765
        SetMap(221,'y');
 
1766
        SetMap(222,'p');
 
1767
        SetMap(231,'c');
 
1768
        SetMap(241,'n');
 
1769
        SetMap(247,'/');
 
1770
        SetMap(248,'o');
 
1771
        SetMap(253,'y');
 
1772
        SetMap(254,'p');
 
1773
        SetMap(255,'y');
 
1774
 
 
1775
        //map 0 to o because they look similar
 
1776
        SetMap('0','o');
 
1777
 
 
1778
        // TODO: make this data driven.
 
1779
    }
 
1780
 
 
1781
    char Filter( unsigned char in )
 
1782
    {
 
1783
        return filter[ static_cast< unsigned int >( in )];
 
1784
    }
 
1785
private:
 
1786
    void SetMap( int in1, int in2, unsigned char out)
 
1787
    {
 
1788
        tASSERT( in2 <= 0xff );
 
1789
        tASSERT( 0 <= in1 );
 
1790
        tASSERT( in1 < in2 );
 
1791
        for( int i = in2; i >= in1; --i )
 
1792
            filter[ i ] = out;
 
1793
    }
 
1794
 
 
1795
    void SetMap( unsigned char in, unsigned char out)
 
1796
    {
 
1797
        filter[ static_cast< unsigned int >( in ) ] = out;
 
1798
    }
 
1799
 
 
1800
    char filter[256];
 
1801
};
 
1802
 
 
1803
static bool st_IsUnderscore( char c )
 
1804
{
 
1805
    return c == '_';
 
1806
}
 
1807
 
 
1808
// function prototype for character testing functions
 
1809
typedef bool TestSCharacter( char c );
 
1810
 
 
1811
// strips characters matching a test beginnings and ends of names
 
1812
static void st_StripMatchingEnds( tString & stripper, TestSCharacter & beginTester, TestSCharacter & endTester)
 
1813
{
 
1814
    int len = stripper.Len() - 1;
 
1815
    int first = 0, last = len;
 
1816
 
 
1817
    // eat whitespace from beginnig and end
 
1818
    while ( first < len && beginTester( stripper[first] ) ) ++first;
 
1819
    while ( last > 0 && ( !stripper[last] || endTester(stripper[last] ) ) ) --last;
 
1820
 
 
1821
    // strip everything?
 
1822
    if ( first > last )
 
1823
    {
 
1824
        stripper = "";
 
1825
        return;
 
1826
    }
 
1827
 
 
1828
    // strip
 
1829
    if ( first > 0 || last < stripper.Len() - 1 )
 
1830
        stripper = stripper.SubStr( first, last + 1 - first );
 
1831
}
 
1832
 
1804
1833
//! @returns filtered string and with all of its characters in lowercased string
1805
 
tString tString::Filter() const
1806
 
{
1807
 
    tString in(*this);
 
1834
tString tString::Filter() const
 
1835
{
 
1836
    tString in(*this);
1808
1837
    tString out;
1809
 
    out = tColoredString::RemoveColors( in );
1810
 
    tStringFilter filter;
1811
 
 
1812
 
    // filter out illegal characters
1813
 
    for (int i = out.Len()-1; i>=0; --i )
1814
 
    {
1815
 
        char & c = out[i];
1816
 
 
1817
 
        c = filter.Filter( c );
1818
 
    }
1819
 
 
1820
 
    // strip leading and trailing unknown characters
1821
 
    st_StripMatchingEnds( out, st_IsUnderscore, st_IsUnderscore );
1822
 
 
1823
 
    return out;
 
1838
    out = tColoredString::RemoveColors( in );
 
1839
    tStringFilter filter;
 
1840
 
 
1841
    // filter out illegal characters
 
1842
    for (int i = out.Len()-1; i>=0; --i )
 
1843
    {
 
1844
        char & c = out[i];
 
1845
 
 
1846
        c = filter.Filter( c );
 
1847
    }
 
1848
 
 
1849
    // strip leading and trailing unknown characters
 
1850
    st_StripMatchingEnds( out, st_IsUnderscore, st_IsUnderscore );
 
1851
 
 
1852
    return out;
1824
1853
}
1825
1854
 
1826
1855
//static const char delimiters[] = "`~!@#$%^&*()-=_+[]\\{}|;':\",./<>? ";
1827
 
//static tString delimiters("!?.:;_()-, ");
 
1856
//static tString delimiters("!?.:;_()-, ");
1828
1857
static tString delimiters("`~!@#$%^&*()-=_+[]\\{}|;':\",./<>? ");
1829
1858
static tConfItemLine st_wordDelimiters( "WORD_DELIMITERS", delimiters );
1830
1859
 
2131
2160
{
2132
2161
    return st_StringEndsWith( test, tString( end ) );
2133
2162
}
2134
 
 
 
2163
 
2135
2164
// **********************************************************************
2136
2165
// *
2137
2166
// *    Contains
2138
2167
// *
2139
2168
// **********************************************************************
2140
2169
//!
2141
 
//!    @param      tofind       The string to search for within the stored string
 
2170
//!    @param      tofind       The string to search for within the stored string
2142
2171
//!    @return     true         Returns true if the string is found
2143
2172
//!
2144
 
// **********************************************************************
2145
 
 
2146
 
bool tString::Contains(tString tofind)
2147
 
{
2148
 
    // if the length of tofind longer than the string, quit it!
2149
 
    if (tofind.Len() > Len())
2150
 
        return false;
2151
 
 
2152
 
    // the total legnth of tofind, minus the 1 extra garbage
2153
 
    int strCount = tofind.Len() - 1;
2154
 
 
2155
 
    for (int i = 0; i < Len(); i++)
2156
 
    {
2157
 
        // strip the string to the length of tofind
2158
 
        tString isThis = this->SubStr(i, strCount);
2159
 
 
2160
 
        // if that stripped string matches, good!
2161
 
        if (isThis == tofind)
2162
 
        {
2163
 
            return true;
2164
 
        }
2165
 
    }
2166
 
    // if they don't match at all, too bad!
2167
 
    return false;
2168
 
}
2169
 
 
2170
 
bool tString::Contains(const char *tofind)
2171
 
{
2172
 
    return Contains(tString(tofind));
2173
 
}
2174
 
 
 
2173
// **********************************************************************
 
2174
 
 
2175
bool tString::Contains(tString tofind)
 
2176
{
 
2177
    // if the length of tofind longer than the string, quit it!
 
2178
    if (tofind.Len() > Len())
 
2179
        return false;
 
2180
 
 
2181
    // the total legnth of tofind, minus the 1 extra garbage
 
2182
    int strCount = tofind.Len() - 1;
 
2183
 
 
2184
    for (int i = 0; i < Len(); i++)
 
2185
    {
 
2186
        // strip the string to the length of tofind
 
2187
        tString isThis = this->SubStr(i, strCount);
 
2188
 
 
2189
        // if that stripped string matches, good!
 
2190
        if (isThis == tofind)
 
2191
        {
 
2192
            return true;
 
2193
        }
 
2194
    }
 
2195
    // if they don't match at all, too bad!
 
2196
    return false;
 
2197
}
 
2198
 
 
2199
bool tString::Contains(const char *tofind)
 
2200
{
 
2201
    return Contains(tString(tofind));
 
2202
}
 
2203
 
2175
2204
// **********************************************************************
2176
2205
// *
2177
2206
// *    RemoveWord
2178
2207
// *
2179
2208
// **********************************************************************
2180
2209
//!
2181
 
//!    @param      find_word       The word to remove from the string
 
2210
//!    @param      find_word       The word to remove from the string
2182
2211
//!    @return     newLine         Returns string without "find_word"
2183
2212
//!
2184
 
// **********************************************************************
2185
 
 
2186
 
tString tString::RemoveWord(tString find_word)
2187
 
{
2188
 
    tString ret(*this);
2189
 
    tString newLine;
2190
 
 
2191
 
    if (find_word.Len() > ret.Len())
2192
 
        return tString("");
2193
 
    else if (find_word == "")
2194
 
        return ret;
2195
 
 
2196
 
    int count_word = find_word.Len() - 1;
2197
 
    int this_word = ret.Len();
2198
 
 
2199
 
    for(int i = 0; i < this_word; i++)
2200
 
    {
2201
 
        tString putWordTogether;
2202
 
        for(int j = 0; j < count_word; j++)
2203
 
        {
2204
 
            putWordTogether << ret[i+j];
2205
 
        }
2206
 
 
2207
 
        if (putWordTogether == find_word)
2208
 
            i += count_word - 1;
2209
 
        else newLine << ret[i];
2210
 
    }
2211
 
 
2212
 
    return newLine;
2213
 
}
2214
 
 
2215
 
tString tString::RemoveWord(const char *find_word)
2216
 
{
2217
 
    return RemoveWord(tString(find_word));
2218
 
}
2219
 
 
2220
 
 
 
2213
// **********************************************************************
 
2214
 
 
2215
tString tString::RemoveWord(tString find_word)
 
2216
{
 
2217
    tString ret(*this);
 
2218
    tString newLine;
 
2219
 
 
2220
    if (find_word.Len() > ret.Len())
 
2221
        return tString("");
 
2222
    else if (find_word == "")
 
2223
        return ret;
 
2224
 
 
2225
    int count_word = find_word.Len() - 1;
 
2226
    int this_word = ret.Len();
 
2227
 
 
2228
    for(int i = 0; i < this_word; i++)
 
2229
    {
 
2230
        tString putWordTogether;
 
2231
        for(int j = 0; j < count_word; j++)
 
2232
        {
 
2233
            putWordTogether << ret[i+j];
 
2234
        }
 
2235
 
 
2236
        if (putWordTogether == find_word)
 
2237
            i += count_word - 1;
 
2238
        else newLine << ret[i];
 
2239
    }
 
2240
 
 
2241
    return newLine;
 
2242
}
 
2243
 
 
2244
tString tString::RemoveWord(const char *find_word)
 
2245
{
 
2246
    return RemoveWord(tString(find_word));
 
2247
}
 
2248
 
 
2249
 
2221
2250
// **********************************************************************
2222
2251
// *
2223
2252
// *    Split
2224
2253
// *
2225
2254
// **********************************************************************
2226
2255
//!
2227
 
//!    @param      delimiter       The expression to exclude when splitting string
 
2256
//!    @param      delimiter       The expression to exclude when splitting string
2228
2257
//!    @return     arrayString     Returns string in array before and after "delimiter"
2229
2258
//!
2230
 
// **********************************************************************
2231
 
 
2232
 
tArray<tString> tString::Split(tString delimiter)
2233
 
{
2234
 
    tString ret(*this);
2235
 
    tArray<tString> arrayString;
2236
 
 
2237
 
    /*  Old Method
2238
 
    if (delimiter.Len() > ret.Len())
2239
 
        return arrayString;
2240
 
    else if (delimiter == "")
2241
 
    {
2242
 
        arrayString[0] = ret;
2243
 
        return arrayString;
2244
 
    }
2245
 
 
2246
 
    int count_word = delimiter.Len() - 1;
2247
 
    int this_word = ret.Len();
2248
 
    int arrayKey = 0;
2249
 
 
2250
 
    for(int i = 0; i < this_word; i++)
2251
 
    {
2252
 
        tString putWordTogether;
2253
 
        for(int j = 0; j < count_word; j++)
2254
 
        {
2255
 
            putWordTogether << ret[i+j];
2256
 
        }
2257
 
 
2258
 
        if (putWordTogether == delimiter)
2259
 
        {
2260
 
            i += count_word - 1;
2261
 
            arrayKey++;
2262
 
        }
2263
 
        else arrayString[arrayKey] << ret[i];
2264
 
    }
2265
 
    */
2266
 
 
2267
 
    //  New Method
2268
 
    int strleng = ret.Len() - 1;
2269
 
    int delleng = delimiter.Len() - 1;
2270
 
    if (delleng == 0)
2271
 
        return arrayString;//no change
2272
 
 
2273
 
    int i = 0;
2274
 
    int k = 0;
2275
 
    while(i < strleng)
2276
 
    {
2277
 
        int j = 0;
2278
 
        while (i + j < strleng && j < delleng && ret[i + j] == delimiter[j])
2279
 
            j++;
2280
 
 
2281
 
        if (j == delleng)//found delimiter
2282
 
        {
2283
 
            arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
2284
 
            i += delleng;
2285
 
            k = i;
2286
 
        }
2287
 
        else
2288
 
        {
2289
 
            i++;
2290
 
        }
2291
 
    }
2292
 
    arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
2293
 
 
2294
 
    return arrayString;
2295
 
}
2296
 
 
2297
 
tArray<tString> tString::Split(const char *delimiter)
2298
 
{
2299
 
    return Split(tString(delimiter));
2300
 
}
2301
 
 
2302
 
tArray<tString> st_explode(tString delimiter, tString ret)
2303
 
{
2304
 
    tArray<tString> arrayString;
2305
 
 
2306
 
    int strleng = ret.Len() - 1;
2307
 
    int delleng = delimiter.Len() - 1;
2308
 
    if (delleng == 0)
2309
 
        return arrayString;//no change
2310
 
 
2311
 
    int i = 0;
2312
 
    int k = 0;
2313
 
    while(i < strleng)
2314
 
    {
2315
 
        int j = 0;
2316
 
        while (i + j < strleng && j < delleng && ret[i + j] == delimiter[j])
2317
 
            j++;
2318
 
 
2319
 
        if (j == delleng)//found delimiter
2320
 
        {
2321
 
            arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
2322
 
            i += delleng;
2323
 
            k = i;
2324
 
        }
2325
 
        else
2326
 
        {
2327
 
            i++;
2328
 
        }
2329
 
    }
2330
 
    arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
2331
 
 
2332
 
    return arrayString;
2333
 
}
2334
 
 
 
2259
// **********************************************************************
 
2260
 
 
2261
tArray<tString> tString::Split(tString delimiter)
 
2262
{
 
2263
    tString ret(*this);
 
2264
    tArray<tString> arrayString;
 
2265
 
 
2266
    /*  Old Method
 
2267
    if (delimiter.Len() > ret.Len())
 
2268
        return arrayString;
 
2269
    else if (delimiter == "")
 
2270
    {
 
2271
        arrayString[0] = ret;
 
2272
        return arrayString;
 
2273
    }
 
2274
 
 
2275
    int count_word = delimiter.Len() - 1;
 
2276
    int this_word = ret.Len();
 
2277
    int arrayKey = 0;
 
2278
 
 
2279
    for(int i = 0; i < this_word; i++)
 
2280
    {
 
2281
        tString putWordTogether;
 
2282
        for(int j = 0; j < count_word; j++)
 
2283
        {
 
2284
            putWordTogether << ret[i+j];
 
2285
        }
 
2286
 
 
2287
        if (putWordTogether == delimiter)
 
2288
        {
 
2289
            i += count_word - 1;
 
2290
            arrayKey++;
 
2291
        }
 
2292
        else arrayString[arrayKey] << ret[i];
 
2293
    }
 
2294
    */
 
2295
 
 
2296
    //  New Method
 
2297
    int strleng = ret.Len() - 1;
 
2298
    int delleng = delimiter.Len() - 1;
 
2299
    if (delleng == 0)
 
2300
        return arrayString;//no change
 
2301
 
 
2302
    int i = 0;
 
2303
    int k = 0;
 
2304
    while(i < strleng)
 
2305
    {
 
2306
        int j = 0;
 
2307
        while (i + j < strleng && j < delleng && ret[i + j] == delimiter[j])
 
2308
            j++;
 
2309
 
 
2310
        if (j == delleng)//found delimiter
 
2311
        {
 
2312
            arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
 
2313
            i += delleng;
 
2314
            k = i;
 
2315
        }
 
2316
        else
 
2317
        {
 
2318
            i++;
 
2319
        }
 
2320
    }
 
2321
    arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
 
2322
 
 
2323
    return arrayString;
 
2324
}
 
2325
 
 
2326
tArray<tString> tString::Split(const char *delimiter)
 
2327
{
 
2328
    return Split(tString(delimiter));
 
2329
}
 
2330
 
 
2331
tArray<tString> st_explode(tString delimiter, tString ret)
 
2332
{
 
2333
    tArray<tString> arrayString;
 
2334
 
 
2335
    int strleng = ret.Len() - 1;
 
2336
    int delleng = delimiter.Len() - 1;
 
2337
    if (delleng == 0)
 
2338
        return arrayString;//no change
 
2339
 
 
2340
    int i = 0;
 
2341
    int k = 0;
 
2342
    while(i < strleng)
 
2343
    {
 
2344
        int j = 0;
 
2345
        while (i + j < strleng && j < delleng && ret[i + j] == delimiter[j])
 
2346
            j++;
 
2347
 
 
2348
        if (j == delleng)//found delimiter
 
2349
        {
 
2350
            arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
 
2351
            i += delleng;
 
2352
            k = i;
 
2353
        }
 
2354
        else
 
2355
        {
 
2356
            i++;
 
2357
        }
 
2358
    }
 
2359
    arrayString[arrayString.Len()] = ret.SubStr(k, i - k);
 
2360
 
 
2361
    return arrayString;
 
2362
}
 
2363
 
2335
2364
// **********************************************************************
2336
2365
// *
2337
2366
// *    Replace
2338
2367
// *
2339
2368
// **********************************************************************
2340
2369
//!
2341
 
//!    @param      old_word       The word to search up
2342
 
//!    @param      new_word       Word to replace with the old one with
 
2370
//!    @param      old_word       The word to search up
 
2371
//!    @param      new_word       Word to replace with the old one with
2343
2372
//!    @return     strString    Returns string
2344
2373
//!
2345
 
// **********************************************************************
2346
 
 
2347
 
tString tString::Replace(tString old_word, tString new_word)
2348
 
{
2349
 
    tString ret(*this);
2350
 
    tString strString;
2351
 
 
2352
 
    if (old_word.Len() > ret.Len())
2353
 
        return tString("");
2354
 
    else if (old_word == "")
2355
 
        return ret;
2356
 
 
2357
 
    int count_word = old_word.Len() - 1;
2358
 
    int count_new = new_word.Len() - 1;
2359
 
    int this_word = ret.Len();
2360
 
 
2361
 
    for(int i = 0; i < this_word; i++)
2362
 
    {
2363
 
        tString putWordTogether;
2364
 
        for(int j = 0; j < count_word; j++)
2365
 
        {
2366
 
            putWordTogether << ret[i + j];
2367
 
        }
2368
 
 
2369
 
        if (putWordTogether.Filter() == old_word.Filter())
2370
 
        {
2371
 
            strString << new_word;
2372
 
            i += count_word - 1;
2373
 
        }
2374
 
        else
2375
 
            strString << ret[i];
2376
 
    }
2377
 
 
2378
 
    return strString;
2379
 
}
2380
 
 
2381
 
tString tString::Replace(const char *old_word, const char *new_word)
2382
 
{
2383
 
    return Replace(tString(old_word), tString(new_word));
2384
 
}
2385
 
 
 
2374
// **********************************************************************
 
2375
 
 
2376
tString tString::Replace(tString old_word, tString new_word)
 
2377
{
 
2378
    tString ret(*this);
 
2379
    tString strString;
 
2380
 
 
2381
    if (old_word.Len() > ret.Len())
 
2382
        return tString("");
 
2383
    else if (old_word == "")
 
2384
        return ret;
 
2385
 
 
2386
    int count_word = old_word.Len() - 1;
 
2387
    int count_new = new_word.Len() - 1;
 
2388
    int this_word = ret.Len();
 
2389
 
 
2390
    for(int i = 0; i < this_word; i++)
 
2391
    {
 
2392
        tString putWordTogether;
 
2393
        for(int j = 0; j < count_word; j++)
 
2394
        {
 
2395
            putWordTogether << ret[i + j];
 
2396
        }
 
2397
 
 
2398
        if (putWordTogether.Filter() == old_word.Filter())
 
2399
        {
 
2400
            strString << new_word;
 
2401
            i += count_word - 1;
 
2402
        }
 
2403
        else
 
2404
            strString << ret[i];
 
2405
    }
 
2406
 
 
2407
    return strString;
 
2408
}
 
2409
 
 
2410
tString tString::Replace(const char *old_word, const char *new_word)
 
2411
{
 
2412
    return Replace(tString(old_word), tString(new_word));
 
2413
}
 
2414
 
2386
2415
// **********************************************************************
2387
2416
// *
2388
2417
// *    IsNumeric
2389
2418
// *
2390
2419
// **********************************************************************
2391
 
//!
 
2420
//!
2392
2421
//!    @return     Returns true if string contains numeric values
2393
2422
//!
2394
 
// **********************************************************************
2395
 
bool tString::IsNumeric()
2396
 
{
2397
 
    tString ret(*this);
2398
 
    tString numericValues("012456789ef.-+");
2399
 
 
2400
 
    //  return false when string is blank
2401
 
    if (ret.Filter() == "")
2402
 
        return false;
2403
 
 
2404
 
    for(int i = 0; i < ret.Len(); i++)
2405
 
    {
2406
 
        bool found = false;
2407
 
        //  return false if current character in string is not a number
2408
 
        for(int id = 0; id < numericValues.Len(); id++)
2409
 
        {
2410
 
            if (ret.ToLower()[i] == numericValues[id])
2411
 
                found = true;
2412
 
        }
2413
 
 
2414
 
        if (!found) return false;
2415
 
    }
2416
 
 
2417
 
    //  looks like everything worked out. Good!
2418
 
    return true;
2419
 
}
2420
 
 
 
2423
// **********************************************************************
 
2424
bool tString::IsNumeric()
 
2425
{
 
2426
    tString ret(*this);
 
2427
    tString numericValues("012456789ef.-+");
 
2428
 
 
2429
    //  return false when string is blank
 
2430
    if (ret.Filter() == "")
 
2431
        return false;
 
2432
 
 
2433
    for(int i = 0; i < ret.Len(); i++)
 
2434
    {
 
2435
        bool found = false;
 
2436
        //  return false if current character in string is not a number
 
2437
        for(int id = 0; id < numericValues.Len(); id++)
 
2438
        {
 
2439
            if (ret.ToLower()[i] == numericValues[id])
 
2440
                found = true;
 
2441
        }
 
2442
 
 
2443
        if (!found) return false;
 
2444
    }
 
2445
 
 
2446
    //  looks like everything worked out. Good!
 
2447
    return true;
 
2448
}
 
2449
 
2421
2450
// **********************************************************************
2422
2451
// *
2423
2452
// *    RemoveCharacter
2424
2453
// *
2425
2454
// **********************************************************************
2426
2455
//!
2427
 
//!    @param      find_word       The word to remove from the string
 
2456
//!    @param      find_word       The word to remove from the string
2428
2457
//!    @return     newLine         Returns string without "find_word"
2429
2458
//!
2430
 
// **********************************************************************
2431
 
 
2432
 
tString tString::RemoveCharacter(char character)
2433
 
{
2434
 
    tString ret(*this);
2435
 
    tString newLine;
2436
 
 
2437
 
    for(int i = 0; i < ret.Len(); i++)
2438
 
    {
2439
 
        if (ret[i] != character)
2440
 
            newLine << ret[i];
2441
 
    }
2442
 
 
2443
 
    return newLine;
2444
 
}
2445
 
 
2446
 
tString htmlentities(tString str)
2447
 
{
2448
 
    tString ret;
2449
 
 
2450
 
    for(int i = 0; i < (str.Len() - 1); i++)
2451
 
    {
2452
 
        switch (str[i])
2453
 
        {
2454
 
            case '\"':  ret << "&quot;";    break;
2455
 
            case '\'':  ret << "&apos;";    break;
2456
 
            case '<':   ret << "&lt;";      break;
2457
 
            case '>':   ret << "&gt;";      break;
2458
 
            case '*':   ret << "&#42;";     break;
2459
 
            case '/':   ret << "&#47;";     break;
2460
 
            case '|':   ret << "&#124;";    break;
2461
 
            case ':':   ret << "&#58;";     break;
2462
 
            case '?':   ret << "&#63;";     break;
2463
 
 
2464
 
            default: ret << str[i]; break;
2465
 
        }
2466
 
    }
2467
 
 
2468
 
    return ret;
2469
 
}
 
2459
// **********************************************************************
 
2460
 
 
2461
tString tString::RemoveCharacter(char character)
 
2462
{
 
2463
    tString ret(*this);
 
2464
    tString newLine;
 
2465
 
 
2466
    for(int i = 0; i < ret.Len(); i++)
 
2467
    {
 
2468
        if (ret[i] != character)
 
2469
            newLine << ret[i];
 
2470
    }
 
2471
 
 
2472
    return newLine;
 
2473
}
 
2474
 
 
2475
tString htmlentities(tString str)
 
2476
{
 
2477
    tString ret;
 
2478
 
 
2479
    for(int i = 0; i < (str.Len() - 1); i++)
 
2480
    {
 
2481
        switch (str[i])
 
2482
        {
 
2483
            case '\"':  ret << "&quot;";    break;
 
2484
            case '\'':  ret << "&apos;";    break;
 
2485
            case '<':   ret << "&lt;";      break;
 
2486
            case '>':   ret << "&gt;";      break;
 
2487
            case '*':   ret << "&#42;";     break;
 
2488
            case '/':   ret << "&#47;";     break;
 
2489
            case '|':   ret << "&#124;";    break;
 
2490
            case ':':   ret << "&#58;";     break;
 
2491
            case '?':   ret << "&#63;";     break;
 
2492
 
 
2493
            default: ret << str[i]; break;
 
2494
        }
 
2495
    }
 
2496
 
 
2497
    return ret;
 
2498
}