KSG-Framework/Text.cpp

//---Include---
#include "Text.h"
#include <sstream>
#include <iomanip>
#ifndef WIN32
#include <string.h>
#endif

using namespace Framework;

// inhalt der Text Klasse aus Text.h
// Konstruktor 
Text::Text()
    : ReferenceCounter(),
    txt( 0 ),
    suchGBeg( 0 ),
    suchGEnd( 0 ),
    precision( 0 )
{
    setText( "" );
}

Text::Text( const Text &txt )
    : Text()
{
    setText( txt );
}

Text::Text( const char *t )
    : Text()
{
    setText( t ); // Text setzen
}

Text::Text( int zahl )
    : Text()
{
    *this = zahl;
}

// Erstellt ein neues Text Objekt mit einer zahl als text
//  num: Die Zahl, die im Text sein soll
Text::Text( double num )
    : Text()
{
    *this = num;
}

// Erstellt ein neues Text Objekt mit einer zahl als text
//  num: Die Zahl, die im Text sein soll
Text::Text( float num )
    : Text()
{
    *this = num;
}

// Destruktor 
Text::~Text()
{
    delete[]txt;
}

void Text::toUpperCase()
{
    if( !txt )
        return;
    int len = textLength( txt );
    for( int i = 0; i < len; i++ )
    {
        if( txt[ i ] >= 'a' && txt[ i ] <= 'z' )
            txt[ i ] = (char)( txt[ i ] - 32 );
        switch( txt[ i ] )
        {
        case 'ü':
            txt[ i ] = 'Ü';
            break;
        case 'ö':
            txt[ i ] = 'Ö';
            break;
        case 'ä':
            txt[ i ] = 'Ä';
            break;
        }
    }
}

void Text::toLowerCase()
{
    if( !txt )
        return;
    int len = textLength( txt );
    for( int i = 0; i < len; i++ )
    {
        if( txt[ i ] >= 'A' && txt[ i ] <= 'Z' )
            txt[ i ] = (char)( txt[ i ] + 32 );
        switch( txt[ i ] )
        {
        case 'Ü':
            txt[ i ] = 'ü';
            break;
        case 'Ö':
            txt[ i ] = 'ö';
            break;
        case 'Ä':
            txt[ i ] = 'ä';
            break;
        }
    }
}

// nicht constant
void Text::setSuchGrenzen( char gBeg, char gEnd ) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
{
    suchGBeg = gBeg;
    suchGEnd = gEnd;
}

void Text::setText( const char *t ) // ersetzt den Text
{
    delete[]txt; // alter Text löschen
    int l = (int)textLength( t ); // Länge des neuen Textes ermitteln
    txt = new char[ (__int64)l + 1 ]; // neuen Text erstellen
    for( int i = 0; i < l; ++i ) // Text befüllen
        txt[ i ] = t[ i ];
    txt[ l ] = '\0'; // Textende Festlegen
}

// unconstant 
void Text::setText( const char *t, int l ) // ersetzt den Text
{
    delete[]txt; // alter Text löschen
    txt = new char[ (__int64)l + 1 ]; // neuen Text erstellen
    for( int i = 0; i < l; ++i ) // Text befüllen
        txt[ i ] = t[ i ];
    txt[ l ] = '\0'; // Textende Festlegen
}

void Text::setText( Text *t )
{
    setText( t->getText() ); // Text setzen
    t->release(); // übergabe loslassen
}

void Text::append( char c ) // hängt an den Text an
{
    append( &c, 1 );
}

void Text::append( const char *t ) // hängt an den Text an
{
    int tl = (int)textLength( t ); // länge der übergabe
    int txl = getLength(); // länge des Textes
    char *res = new char[ (__int64)tl + txl + 1 ]; // neuen Text erstellen
    for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
        res[ i ] = txt[ i ];
    for( int i = 0; i < tl; ++i ) // Übergabe anhängen
        res[ txl + i ] = t[ i ];
    res[ txl + tl ] = '\0'; // Textende festlegen
    setText( res ); // Test setzen
    delete[] res; // Speicher freigeben
}

void Text::appendHex( int num ) // hängt die zahl in hex anden Text an
{
    int l = getLength();
    char *res = new char[ (__int64)l + 9 ];
    for( int i = 0; i < l; ++i )
        res[ i ] = txt[ i ];
    std::stringstream stream;
    stream << std::setfill( '0' ) << std::setw( (int)sizeof( int ) * 2 ) << std::hex << num;
    std::string str = stream.str();
    for( int i = l; i < l + 8; ++i )
        res[ i ] = str.c_str()[ i - l ];
    res[ l + 8 ] = 0;
    setText( res );
    delete[] res;
}

void Text::append( const char *t, int l ) // hängt an den Text an
{
    int txl = getLength(); // länge des Textes
    char *res = new char[ (__int64)l + txl + 1 ]; // neuen Text erstellen
    for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
        res[ i ] = txt[ i ];
    for( int i = 0; i < l; ++i ) // Übergabe anhängen
        res[ txl + i ] = t[ i ];
    res[ txl + l ] = '\0'; // Textende festlegen
    setText( res, txl + l ); // Test setzen
    delete[] res; // Speicher freigeben
}

void Text::append( Text *t )
{
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        append( t->getText() ); // Text anhängen
    t->release(); // Übergabe loslassen
}

void Text::append( int num )
{
    std::stringstream ss;
    ss << num;
    append( ss.str().c_str() );
}

// Hängt eine Zahl ans Ende Des Textes an
//  num: Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
void Text::append( __int64 num )
{
    std::stringstream ss;
    ss << num;
    append( ss.str().c_str() );
}

void Text::append( unsigned int num )
{
    std::stringstream ss;
    ss << num;
    append( ss.str().c_str() );
}

void Text::append( double num )
{
    std::stringstream ss;
    ss.precision( precision );
    ss << num;
    append( ss.str().c_str() );
}

void Text::append( float num )
{
    std::stringstream ss;
    ss.precision( precision );
    ss << num;
    append( ss.str().c_str() );
}

void Text::insert( int p, char c ) // Fügt an stelle p ein
{
    if( p > getLength() || p < 0 ) // Auf unsinnige übergabe prüfen
        return;
    int txl = getLength(); // Länge des Textes
    char *res = new char[ (__int64)txl + 2 ]; // neuer Text erstellen
    for( int i = 0; i < p; ++i ) // Text füllen
        res[ i ] = txt[ i ];
    res[ p ] = c;
    for( int i = p; i < txl; ++i ) // Text füllen
        res[ i + 1 ] = txt[ i ];
    res[ txl + 1 ] = '\0'; // Text ende festlegen
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::insert( int p, const char *t ) // Fügt an stelle p ein
{
    if( p > getLength() || p < 0 || textLength( t ) <= 0 ) // Auf unsinnige übergabe prüfen
        return;
    int tl = (int)textLength( t ); // Länge der übergabe
    int txl = getLength(); // Länge des Textes
    char *res = new char[ (__int64)tl + txl + 1 ]; // neuer Text erstellen
    for( int i = 0; i < p; ++i ) // Text füllen
        res[ i ] = txt[ i ];
    for( int i = 0; i < tl; ++i ) // Text einfügen
        res[ i + p ] = t[ i ];
    for( int i = p; i < txl; ++i ) // Text füllen
        res[ i + tl ] = txt[ i ];
    res[ tl + txl ] = '\0'; // Text ende festlegen
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::insert( int p, Text *t )
{
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        insert( p, t->getText() ); // Text einfügen
    t->release(); // Übergabe loslassen
}

void Text::ersetzen( int p1, int p2, const char *t ) // Ersetzt den Text von p1 bis p2
{
    if( p1 > p2 )
    {
        int x = p1; // p1 und p2 tauschen
        p1 = p2;
        p2 = x;
    }
    remove( p1, p2 ); // Textabschnitt von p1 zu p2 löschen
    insert( p1, t ); // Übergabe bei p1 einfügen
}

void Text::ersetzen( int p1, int p2, Text *t )
{
    if( t->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( p1, p2, t->getText() ); // Text ersetzen
    t->release(); // Übergabe loslassen
}

void Text::ersetzen( char c1, char c2 ) // ersetzt jedes c1 durch c2
{
    if( c1 == '\0' || c2 == '\0' ) // Auf unsinnige übergabe prüfen
        return;
    if( !hat( c1 ) ) // prüfen ob c1 vorhanden
        return;
    int l = getLength(); // Text Länge
    int suchGCount = 0;
    for( int i = 0; i < l; ++i ) // Text durchsuchen
    {
        bool b = suchGCount != 0;
        if( txt[ i ] == c1 && !suchGCount )
            txt[ i ] = c2; // Text ersetzen
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( txt[ i ] == c1 && !suchGCount && b )
            txt[ i ] = c2; // Text ersetzen
    }
}

void Text::ersetzen( const char *t1, const char *t2 ) // ersetzt jedes t1 durch t2
{
    int txl = getLength(); // Text Länge
    int t1l = (int)textLength( t1 ); // Länge der Übergaben
    int t2l = (int)textLength( t2 );
    if( t1l > txl || t1l <= 0 ) // Auf unsinnige übergabe prüfen
        return;
    if( !hat( t1 ) ) // prüfen ob t1 vorhanden
        return;
    int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
    int *begin = new int[ anz ];
    int *end = new int[ anz ];
    for( int i = 0; i < anz; ++i ) // Positionen von t1 speichern
    {
        begin[ i ] = positionVon( t1, i );
        end[ i ] = begin[ i ] + t1l;
    }
    int resl = ( txl - ( anz * t1l ) ) + ( anz * t2l ) + 1; // Länge des Ergebneses
    char *res = new char[ resl ]; // neuer Text erstellen
    int rep = 0; // Speichert bei welchen t1 man sich befindet
    int last = 0; // Füllposition von txt
    int neu = 0; // Füllporition von res
    for( ; neu < resl; ++neu ) // Text befüllen
    {
        if( rep < anz && last == begin[ rep ] ) // Text ersetzen
        {
            last = end[ rep ];
            ++rep;
            for( int ii = 0; ii < t2l; ++ii )
            {
                if( neu >= resl )
                    break;
                res[ neu ] = t2[ ii ];
                ++neu;
            }
            if( neu >= resl )
                break;
            --neu;
        }
        else // Text Kopieren
        {
            res[ neu ] = txt[ last ];
            ++last;
        }
    }
    res[ resl - 1 ] = '\0'; // Textende festlegen
    setText( res ); // Text setzen
    delete[]begin; // Speicher freigeben
    delete[]end;
    delete[] res;
}

void Text::ersetzen( Text *t1, const char *t2 )
{
    if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( t1->getText(), t2 ); // ersetzen
    t1->release(); // Übergabe loslassen
}

void Text::ersetzen( const char *t1, Text *t2 )
{
    if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( t1, t2->getText() ); // ersetzen
    t2->release(); // Übergabe loslassen
}

void Text::ersetzen( Text *t1, Text *t2 )
{
    if( t1->getLength() > 0 && t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( t1->getText(), t2->getText() ); // ersetzen
    t1->release(); // Übergaben loslassen
    t2->release();
}

void Text::ersetzen( int index, char c1, char c2 ) // ersetzt das i-te c1 durch c2
{
    if( c1 == '\0' || c2 == '\0' || index < 0 ) // Auf unsinnige übergabe prüfen
        return;
    if( !hat( c1 ) ) // prüfen ob c1 vorhanden
        return;
    int anz = anzahlVon( c1 );
    if( index >= anz ) // prüfen ob es ein i-tes c1 gibt
        return;
    txt[ positionVon( c1, index ) ] = c2;
}

void Text::ersetzen( int index, const char *t1, const char *t2 ) // ersetzt das i-te t1 durch t2
{
    int txl = getLength(); // Text Länge
    int t1l = (int)textLength( t1 ); // Länge der Übergaben
    if( t1l >= txl || t1l <= 0 || index < 0 ) // Auf unsinnige übergabe prüfen
        return;
    if( !hat( t1 ) ) // prüfen ob t1 vorhanden
        return;
    int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
    if( index >= anz ) // prüfen ob es ein i-tes t1 gibt
        return;
    int begin = positionVon( t1, index );
    int end = begin + t1l;
    ersetzen( begin, end, t2 ); // ersetzen
}

void Text::ersetzen( int i, Text *t1, const char *t2 )
{
    if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( i, t1->getText(), t2 ); // ersetzen
    t1->release(); // Übergabe loslassen
}

void Text::ersetzen( int i, const char *t1, Text *t2 )
{
    if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( i, t1, t2->getText() ); // ersetzen
    t2->release(); // Übergabe loslassen
}

void Text::ersetzen( int i, Text *t1, Text *t2 )
{
    if( t1->getLength() > 0 || t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
        ersetzen( i, t1->getText(), t2->getText() ); // ersetzen
    t1->release(); // Übergaben loslassen
    t2->release();
}

void Text::fillText( char c, int len ) // setzt den Text zu so vielen c wie län groß ist
{
    char *res = new char[ (__int64)len + 1 ];
    for( int i = 0; i < len; ++i )
        res[ i ] = c;
    res[ len ] = '\0';
    setText( res );
    delete[] res;
}

void Text::remove( int p ) // löscht p
{
    int l = getLength(); // Text Länge
    if( p < 0 || p >= l ) // Auf unsinnige übergabe prüfen
        return;
    char *res = new char[ l ]; // neuen Text anlegen
    for( int i = 0; i < p && i < l; ++i ) // Text befüllen
        res[ i ] = txt[ i ];
    for( int i = p + 1; i < l; ++i )
        res[ i - 1 ] = txt[ i ];
    res[ l - 1 ] = 0;
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::remove( int p1, int p2 ) // löscht von p1 zu p2 ( p2 bleibt )
{
    if( p1 == p2 )
        return;
    if( p1 > p2 ) // p1 und p2 tauschen
    {
        int x = p1;
        p1 = p2;
        p2 = x;
    }
    int l = getLength(); // Länge des Testes
    if( p1 < 0 ) // Auf unsinnige übergabe prüfen
        p1 = 0;
    if( p2 > l )
        p2 = l;
    int resl = l - ( p2 - p1 ); // Länge vom Ergebnis
    char *res = new char[ (__int64)resl + 1 ]; // Neuen Text erstellen
    for( int i = 0; i < p1; ++i ) // Text füllen
        res[ i ] = txt[ i ];
    for( int i = p2; i < l; ++i )
        res[ i - ( p2 - p1 ) ] = txt[ i ];
    res[ resl ] = '\0'; // Testende festlegen
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::remove( char c ) // löscht jetes c
{
    if( !hat( c ) ) // prüfen ob c vorhanden
        return;
    int l = getLength(); // Länge des Textes
    int anz = anzahlVon( c ); // Anzahl von c
    char *res = new char[ (__int64)l - anz + 1 ]; // neuen Text erstellen
    int anz2 = 0;
    int suchGCount = 0;
    for( int i = 0; i < l; ++i ) // Text befüllen
    {
        bool b = suchGCount != 0;
        if( txt[ i ] == c && !suchGCount )
            ++anz2;
        else
            res[ i - anz2 ] = txt[ i ];
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( b )
        {
            if( txt[ i ] == c && !suchGCount )
                ++anz2;
            else
                res[ i - anz2 ] = txt[ i ];
        }
    }
    res[ l - anz ] = '\0'; // Textende festlegen
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::remove( const char *t ) // löscht jetes t
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    int txl = getLength(); // Länge des Textes
    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
        return;
    if( !hat( t ) ) // prüfen ob Text ein t enthält
        return;
    int anz = anzahlVon( t ); // anzahl von t
    int *begin = new int[ anz ];
    for( int i = 0; i < anz; ++i ) // begin aller t-s finden
        begin[ i ] = positionVon( t, i );
    int resl = txl - ( anz * tl ); // Länge vom Ergebnes
    char *res = new char[ (__int64)resl + 1 ]; // neuen Text erzeugen
    int del = 0;
    for( int i = 0; i < txl; ++i ) // Text befüllen
    {
        if( del < anz && i == begin[ del ] ) // Text auslassen
        {
            i += tl - 1;
            ++del;
        }
        else
            res[ i - ( del * tl ) ] = txt[ i ]; // Text befüllen
    }
    res[ resl ] = '\0'; // Text ende festlegen
    setText( res ); // Text setzen
    delete[]begin;
    delete[] res; // Speicher freigeben
}

void Text::remove( Text *t )
{
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        remove( t->getText() ); // löschen
    t->release(); // Übergabe loslassen
}

void Text::remove( int index, char c )
{
    if( index < 0 || !hat( c ) ) // Auf unsinnige übergabe prüfen
        return;
    int anz = anzahlVon( c ); // anzahl der i-s
    if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
        return;
    int pos = positionVon( c, index ); // Position vom i-ten c
    if( pos < 0 )
        return;
    int l = getLength(); // Länge des Textes
    if( !l )
        return;
    char *res = new char[ l ]; // neuen Text erzeugen
    for( int i = 0; i < pos && i < l; ++i ) // Text befüllen
        res[ i ] = txt[ i ];
    for( int i = pos + 1; i < l; ++i )
        res[ i - 1 ] = txt[ i ];
    res[ l - 1 ] = '\0'; // Text ende festlegen
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::remove( int index, const char *t ) // löscht das i-te t
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    if( index < 0 || !hat( t ) || tl <= 0 ) // Auf unsinnige übergabe prüfen
        return;
    int anz = anzahlVon( t ); // anzahl der i-s
    if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
        return;
    int pos = positionVon( t, index ); // Position vom i-ten c
    if( pos < 0 )
        return;
    int l = getLength(); // Länge des Textes
    if( !l )
        return;
    char *res = new char[ (__int64)l - tl + 1 ]; // neuen Text erzeugen
    for( int i = 0; i < pos && i < l - tl + 1; ++i ) // Text befüllen
        res[ i ] = txt[ i ];
    for( int i = pos + tl; i < l; ++i )
        res[ i - tl ] = txt[ i ];
    res[ l - tl ] = '\0'; // Text ende festlegen
    setText( res ); // Text setzen
    delete[] res; // Speicher freigeben
}

void Text::remove( int i, Text *t )
{
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        remove( i, t->getText() ); // löschen
    t->release(); // Übergabe loslassen
}

// Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
//  pos: Die Position des ersten zeichens
void Text::removeWhitespaceAfter( int pos )
{
    int length = 0;
    int len = textLength( txt );
    for( int i = pos; i < len; i++ )
    {
        if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
            length++;
        else
            break;
    }
    remove( pos, pos + length );
}

// Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
//  pos: Die Position des ersten zeichens (beginnt bei pos-1)
void Text::removeWhitespaceBefore( int pos )
{
    int length = 0;
    for( int i = pos - 1; i >= 0; i-- )
    {
        if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
            length++;
        else
            break;
    }
    remove( pos - length, pos );
}

void Text::setPrecision( int p ) // setzt die Anzahl der Nachkommastellen bei doubles
{
    precision = p;
}

// constant 
int Text::getLength() const // gibt die Text länge zurück
{
    if( !txt )
        return -1;
    return textLength( txt );
}

int Text::getLKick( int pos ) const
{
    if( txt[ pos - 1 ] == ' ' )
    {
        int ret = 1;
        for( ; ret < pos && txt[ pos - ret - 1 ] == ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
        return pos - ret;
    }
    else
    {
        int ret = 1;
        for( ; ret < pos && txt[ pos - ret - 1 ] != ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
        return pos - ret;
    }
}

int Text::getOKick( int pos ) const
{
    if( !hat( '\n' ) )
        return 0;
    int lpos = 0;
    while( pos - lpos - 1 > 0 && txt[ pos - lpos - 1 ] != '\n' )
        ++lpos;
    int vllen = 1;
    while( pos - lpos - vllen - 1 >= 0 && txt[ pos - lpos - vllen - 1 ] != '\n' )
        ++vllen;
    if( vllen > lpos )
        return pos - vllen;
    else
        return pos - lpos - 1;
}

int Text::getRKick( int pos ) const
{
    int tl = getLength();
    if( txt[ pos ] == ' ' )
    {
        int ret = 1;
        for( ; ret + pos < tl && txt[ pos + ret ] == ' ' && txt[ pos + ret ] != '\n'; ++ret );
        return pos + ret;
    }
    else
    {
        int ret = 1;
        for( ; ret + pos < tl && txt[ pos + ret ] != ' ' && txt[ pos + ret ] != '\n'; ++ret );
        return pos + ret;
    }
}

int Text::getUKick( int pos ) const
{
    if( !hat( '\n' ) )
        return getLength();
    int lpos = 0;
    while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
        ++lpos;
    int llen = 1;
    while( pos + llen - 1 < getLength() && txt[ pos + llen - 1 ] != '\n' )
        ++llen;
    int vllen = 1;
    while( pos + llen + vllen - 1 < getLength() && txt[ pos + llen + vllen - 1 ] != '\n' )
        ++vllen;
    if( vllen == 1 )
        return pos + llen < getLength() ? pos + llen : getLength();
    if( vllen < lpos )
        return pos + llen + vllen - 1;
    return pos + llen + lpos;
}

bool Text::hat( Text *t ) const // enthält der Text t
{
    bool ret = 0;
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        ret = hat( t->getText() ); // prüfen
    t->release(); // Übergabe loslassen
    return ret;
}

bool Text::hat( const char *t ) const
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    int txl = getLength(); // Länge des Textes
    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
        return 0;
    int suchGCount = 0;
    for( int i = 0; i + tl <= txl; ++i ) // Text durchsuchen
    {
        if( !suchGCount )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
                return 1;
        }
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( !suchGCount )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
                return 1;
        }
    }
    return 0;
}

// Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
//  t: Der Text, nach dessen Inhalt gesucht werden soll
//  return: (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
//  pos: die position an der die zeichenkette im string beginnen soll
bool Text::hatAt( int pos, Text *t ) const
{
    bool ret = 0;
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        ret = hatAt( pos, t->getText() ); // prüfen
    t->release(); // Übergabe loslassen
    return ret;
}

// Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
//  t: Die Zeichenkette, nach der gesucht werden soll
//  return: (true), wenn die Zeichenkette vorkommt. (false) sonnst
//  pos: die position an der die zeichenkette im string beginnen soll
bool Text::hatAt( int pos, const char *t ) const
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    int txl = getLength(); // Länge des Textes
    if( tl <= 0 || tl + pos > txl ) // Auf unsinnige übergabe prüfen
        return 0;
    bool b = 1;
    for( int i = 0; i < tl; ++i ) // Text überprüfen
        b &= txt[ pos + i ] == t[ i ];
    return b;
}

bool Text::hat( char c ) const // enthält c
{
    int l = getLength(); // Text Länge
    bool ret = 0;
    int suchGCount = 0;
    for( int i = 0; i < l; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        if( !suchGCount ) // überprüfen
            ret |= txt[ i ] == c;
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( !suchGCount && b ) // überprüfen
            ret |= txt[ i ] == c;
    }
    return ret;
}

bool Text::istGleich( const char *t ) const // prüft ob det Text gleich t ist
{
    int txl = getLength(); // Text Länge
    int tl = (int)textLength( t ); // Länge der Übergabe
    if( txl != tl ) // Auf unsinniege Übergabe prüfen
        return 0;
    if( txl == -1 )
        return 1;
    bool ret = true;
    for( int i = 0; i < tl; ++i ) // prüfen
        ret &= txt[ i ] == t[ i ];
    return ret;
}

bool Text::istGleich( Text *t ) const
{
    bool ret = istGleich( t->getText() ); // prüfen
    t->release(); // Übergabe loslassen
    return ret;
}

char *Text::getText() const // gibt Text zurück
{
    return txt;
}

int Text::anzahlVon( char c ) const // gibt die Anzahl von c im Text zurück
{
    int ret = 0;
    int l = getLength(); // Text Länge
    int suchGCount = 0;
    for( int i = 0; i < l; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        ret += txt[ i ] == c && !suchGCount; // zählen
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        ret += txt[ i ] == c && !suchGCount && b; // zählen
    }
    return ret;
}

int Text::anzahlVon( const char *t ) const // gibt die Anzahl von t im Text zurück
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    int txl = getLength(); // Länge des Textes
    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
        return 0;
    int ret = 0;
    int suchGCount = 0;
    for( int i = 0; i + tl <= txl; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        if( !suchGCount )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
                ++ret; // zählen
        }
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( !suchGCount && b )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
                ++ret; // zählen
        }
    }
    return ret;
}

int Text::anzahlVon( Text *t ) const
{
    int ret = 0;
    if( t->getLength() > 0 )  // Auf unsinnige übergabe prüfen
        ret = anzahlVon( t->getText() ); // zählen
    t->release(); // Übergabe loslassen
    return ret;
}

int Text::positionVon( char c ) const // gibt die Position des ersten c zurück
{
    int l = getLength(); // Text Länge
    int suchGCount = 0;
    for( int i = 0; i < l; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        if( txt[ i ] == c && !suchGCount ) // überprüfen
            return i;
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( txt[ i ] == c && !suchGCount && b ) // überprüfen
            return i;
    }
    return -1;
}

int Text::positionVon( const char *t ) const // gibt die Position des ersten t zurück
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    int txl = getLength(); // Länge des Textes
    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
        return -1;
    int suchGCount = 0;
    for( int i = 0; i + tl <= txl; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        if( !suchGCount )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
                return i;
        }
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( !suchGCount && b )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
                return i;
        }
    }
    return -1;
}

int Text::positionVon( Text *t ) const
{
    int ret = 0;
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        ret = positionVon( t->getText() ); // position ermitteln
    t->release(); // Übergabe loslassen
    return ret;
}

int Text::positionVon( char c, int index ) const // gibt die Position des i-ten c zurück
{
    int l = getLength(); // Text Länge
    int ii = 0;
    int suchGCount = 0;
    for( int i = 0; i < l; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        if( txt[ i ] == c && !suchGCount ) // überprüfen
        {
            if( ii == index )
                return i;
            else
                ++ii;
        }
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( txt[ i ] == c && !suchGCount && b ) // überprüfen
        {
            if( ii == index )
                return i;
            else
                ++ii;
        }
    }
    return -1;
}

int Text::positionVon( const char *t, int index ) const // gibt die Position des i-ten t zurück
{
    int tl = (int)textLength( t ); // Länge der Übergabe
    int txl = getLength(); // Länge des Textes
    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
        return 0;
    int i2 = 0;
    int suchGCount = 0;
    for( int i = 0; i + tl <= txl; ++i ) // suchen
    {
        bool b = suchGCount != 0;
        if( !suchGCount )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
            {
                if( i2 == index )
                    return i;
                else
                    ++i2;
            }
        }
        if( txt[ i ] == suchGBeg )
            ++suchGCount;
        if( txt[ i ] == suchGEnd )
            --suchGCount;
        if( !suchGCount && b )
        {
            bool b = 1;
            for( int ii = 0; ii < tl; ++ii ) // überprüfen
                b &= txt[ i + ii ] == t[ ii ];
            if( b )
            {
                if( i2 == index )
                    return i;
                else
                    ++i2;
            }
        }
    }
    return -1;
}

int Text::positionVon( Text *t, int i ) const
{
    int ret = 0;
    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
        ret = positionVon( t->getText(), i ); // position ermitteln
    t->release(); // Übergabe loslassen
    return ret;
}

Text *Text::getTeilText( int p1, int p2 ) const // gibt den Text von p1 bis p2 zurück
{
    if( p1 > p2 ) // p1 und p2 tauschen
    {
        int x = p1;
        p1 = p2;
        p2 = x;
    }
    int l = getLength(); // Text Länge
    if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
        return new Text( "" );
    char *cp = new char[ (__int64)p2 - p1 + 1 ]; // neuen Text erstellen
    for( int i = p1; i < p2; ++i ) // Text befüllen
    {
        cp[ i - p1 ] = txt[ i ];
    }
    cp[ p2 - p1 ] = '\0';
    Text *t = new Text( cp ); // Text zurückgeben
    delete[]cp;
    return t;
}

Text *Text::getTeilText( int p ) const // gibt den Text von p bis zum Ende zurück
{
    return getTeilText( p, getLength() ); // Text zurückgeben
}

// Operatoren
Text &Text::operator+=( const int num )
{
    append( num );
    return *this;
}

// Hängt eine Zahl ans Ende des Textes an
Text &Text::operator+=( const __int64 num )
{
    append( num );
    return *this;
}

Text &Text::operator+=( const double num )
{
    append( num );
    return *this;
}

Text &Text::operator+=( const float num )
{
    append( num );
    return *this;
}

Text &Text::operator+=( const char *txt )
{
    append( txt );
    return *this;
}

Text &Text::operator+=( const Text &txt )
{
    append( txt.getText() );
    return *this;
}

Text &Text::operator=( const int num )
{
    setText( "" );
    append( num );
    return *this;
}

Text &Text::operator=( const double num )
{
    setText( "" );
    append( num );
    return *this;
}

Text &Text::operator=( const float num )
{
    setText( "" );
    append( num );
    return *this;
}

Text &Text::operator=( const char *txt )
{
    setText( txt );
    return *this;
}

Text &Text::operator=( const Text &txt )
{
    setText( txt.getText() );
    return *this;
}

Text::operator char *( ) const
{
    return txt;
}

Text::operator int() const
{
    if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
        return TextZuInt( ( txt + 2 ), 16 );
    return TextZuInt( txt, 10 );
}

Text::operator __int64() const
{
    if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
        return TextZuInt64( ( txt + 2 ), 16 );
    return TextZuInt64( txt, 10 );
}

Text::operator double() const
{
    return TextZuDouble( txt );
}

Text::operator float() const
{
    return TextZuFloat( txt );
}

bool Text::operator>( Text &t ) const
{
    int len1 = getLength();
    int len2 = t.getLength();
    char *txt2 = t;
    for( int i = 0; i < len1 && i < len2; ++i )
    {
        if( txt[ i ] > txt2[ i ] )
            return 1;
        if( txt[ i ] < txt2[ i ] )
            return 0;
    }
    if( len1 > len2 )
        return 1;
    return 0;
}

bool Text::operator<( Text &t ) const
{
    int len1 = getLength();
    int len2 = t.getLength();
    char *txt2 = t;
    for( int i = 0; i < len1 && i < len2; ++i )
    {
        if( txt[ i ] < txt2[ i ] )
            return 1;
        if( txt[ i ] > txt2[ i ] )
            return 0;
    }
    if( len1 < len2 )
        return 1;
    return 0;
}

// Erstellt einen neuen Text bestehend aus diesem und t2
Text Text::operator+( const Text &t2 ) const
{
    return Text( *this ) += t2;
}

// Erstellt einen neuen Text bestehend aus diesem und t2
Text Text::operator+( const char *t2 ) const
{
    return Text( *this ) += t2;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+( const int num ) const
{
    return Text( *this ) += num;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+( const __int64 num ) const
{
    return Text( *this ) += num;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+( const double num ) const
{
    return Text( *this ) += num;
}

// Erstellt einen neuen Text bestehend aus diesem und num
Text Text::operator+( const float num ) const
{
    return Text( *this ) += num;
}


// Inhalt der TextReader Klasse
// Konstructor
//  txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
TextReader::TextReader( Text *txt )
    : ReferenceCounter()
{
    this->txt = txt;
    lPos = 0;
}

// Destructor
TextReader::~TextReader()
{
    txt->release();
}

// Setzt die Position des Bytes, das als nächstes gelesen werden soll
//  pos: Der Index des Bytes
//  ende: 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
void TextReader::setLPosition( __int64 pos, bool ende )
{
    int l = txt->getLength();
    lPos = ende ? l - pos : pos;
    if( lPos < 0 )
        lPos = 0;
    if( lPos > l )
        lPos = l;
}

// Ließt aus der Datei
//  bytes: Ein Array, der mit Bytes aus dem Text gefüllt werden soll
//  len: Wie viele Bytes aus dem Text gelesen werden sollen
void TextReader::lese( char *bytes, int len )
{
    int l = txt->getLength();
    len = (int)MIN( l - lPos, len );
    for( __int64 i = lPos; i < lPos + len; i++ )
        bytes[ i - lPos ] = txt->getText()[ i ];
    lPos += len;
}

// Ließt die nächste zeile des Textes ein
//  return: Die gelesene Zeile als Text mit zeilenumbruch
Text *TextReader::leseZeile()
{
    if( istEnde() )
        return 0;
    Text *ret = new Text( "" );
    __int64 len = txt->getLength();
    for( char c = 0; c != '\n' && lPos < len; )
    {
        lese( &c, 1 );
        if( c )
            ret->append( (const char *)&c, 1 );
    }
    return ret;
}

// Prüft, ob die Resource vollständig gelesen wurde
//  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
bool TextReader::istEnde() const
{
    return lPos >= txt->getLength();
}

// Gibt den Index des Bytes aus dem Text zurück, welches als nächstes gelesen werden würde
// return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
__int64 TextReader::getLPosition() const
{
    return lPos;
}

//! Gibt die Anzahl der zu lesenden Bytes zurück
__int64 TextReader::getSize() const
{
    return txt->getLength();
}

// char* operationen
int Framework::stringPositionVonChar( char *string, char c, int num ) // sucht die position des num-ten c-s in string, -1 bei nicht gefunden
{
    int gef = 0;
    int p = 0;
    for( char cc = *string; *string; ++string )
    {
        if( cc == c )
        {
            if( gef == num )
                return p;
            else
                ++gef;
        }
        ++p;
    }
    return -1;
}

int Framework::stringPositionVonString( char *string, char *suche, int sBegPos ) // sucht die position von 'suche' in 'string' ab der Position 'sBegPos', -1 bei nicht gefunden
{
    for( int i = 0; i < sBegPos; ++i )
    {
        if( !*string )
            return -1;
        ++string;
    }
    int tl = textLength( suche ); // Länge der Übergabe
    int txl = textLength( string ); // Länge des Textes
    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
        return -1;
    for( int i = 0; i + tl <= txl; ++i ) // suchen
    {
        bool b = 1;
        for( int ii = 0; ii < tl; ++ii ) // überprüfen
            if( b )
                b = string[ i + ii ] == suche[ ii ];
        if( b )
            return i + sBegPos;
    }
    return -1;
}

//---Andere Funktionen---
void Framework::TextKopieren( const char *txt ) // kopiert den Text in den Zwischenspeicher
{
#ifdef WIN32
    int län = textLength( txt ) + 1;
    if( län == 1 )
        return;
    HGLOBAL hMem = GlobalAlloc( GMEM_MOVEABLE, län );
    if( !hMem )
        return;
    memcpy( GlobalLock( hMem ), txt, län );
    GlobalUnlock( hMem );
    OpenClipboard( 0 );
    EmptyClipboard();
    SetClipboardData( CF_TEXT, hMem );
    CloseClipboard();
#endif
}

char *Framework::TextInsert() // gibt den Text aus der Zwischenablage zurück
{
#ifdef WIN32
    if( !OpenClipboard( 0 ) )
        return "";
    HANDLE hClipData = GetClipboardData( CF_TEXT );
    char *cBuffer = (char *)GlobalLock( hClipData );
    GlobalUnlock( hClipData );
    CloseClipboard();
    return cBuffer;
#else
    return 0;
#endif
}

char Framework::smallOrBig( char c, bool gr )
{
    int ret = c;
    if( gr )
    {
        if( c >= 'a' && c <= 'z' )
            ret -= 32;
        else
        {
            switch( c )
            {
            case '^':
                return '°';
            case '1':
                return '!';
            case '<':
                return '>';
            case '2':
                return '\"';
            case '3':
                return '§';
            case '4':
                return '$';
            case '5':
                return '%';
            case '6':
                return '&';
            case '7':
                return '/';
            case '8':
                return '(';
            case '9':
                return ')';
            case '0':
                return '=';
            case ',':
                return ';';
            case '.':
                return ':';
            case 'ß':
                return '?';
            case '-':
                return '_';
            case '´':
                return '`';
            case '+':
                return '*';
            case '#':
                return '\'';
            case 'ü':
                return 'Ü';
            case 'ö':
                return 'Ö';
            case 'ä':
                return 'Ä';
            }
        }
    }
    else
    {
        if( c >= 'A' && c <= 'Z' )
            ret += 32;
        else
        {
            switch( c )
            {
            case '°':
                return '^';
            case '!':
                return '1';
            case '>':
                return '<';
            case '\"':
                return '2';
            case '§':
                return '3';
            case '$':
                return '4';
            case '%':
                return '5';
            case '&':
                return '6';
            case '/':
                return '7';
            case '(':
                return '8';
            case ')':
                return '9';
            case '=':
                return '0';
            case ';':
                return ',';
            case ':':
                return '.';
            case '?':
                return 'ß';
            case '_':
                return '-';
            case '`':
                return '´';
            case '*':
                return '+';
            case '\'':
                return '#';
            case 'Ü':
                return 'ü';
            case 'Ö':
                return 'ö';
            case 'Ä':
                return 'ä';
            }
        }
    }
    return (char)ret;
}

bool Framework::istSchreibbar( unsigned char zeichen ) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
{
    if( zeichen > 32 && zeichen < 127 )
        return 1;
    if( zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179 )
        return 1;
    if( zeichen > 191 && zeichen < 198 )
        return 1;
    if( zeichen > 199 && zeichen < 208 )
        return 1;
    if( zeichen > 209 && zeichen < 215 )
        return 1;
    if( zeichen > 216 && zeichen < 221 )
        return 1;
    if( zeichen > 222 && zeichen < 230 )
        return 1;
    if( zeichen > 231 && zeichen < 240 )
        return 1;
    if( zeichen > 241 && zeichen < 247 )
        return 1;
    if( zeichen > 248 && zeichen < 253 )
        return 1;
    if( zeichen == ' ' || zeichen == '\t' )
        return 1;
    return 0;
}

unsigned int Framework::TextZuInt( char *c, int system ) // Konvertiert c zu int
{
    if( system == 16 )
        return (unsigned int)strtoul( c, 0, system );
    return (unsigned int)strtol( c, 0, system );
}

unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
{
    if( system == 16 )
        return (unsigned int)strtoul( c, c_ende, system );
    return (unsigned int)strtol( c, c_ende, system );
}

unsigned __int64 Framework::TextZuInt64( char *c, int system )
{
    if( system == 16 )
        return strtoull( c, 0, system );
    return (unsigned __int64)strtoll( c, 0, system );
}

unsigned __int64 Framework::TextZuInt64( char *c, char **c_ende, int system )
{
    if( system == 16 )
        return strtoull( c, c_ende, system );
    return (unsigned __int64)strtoll( c, c_ende, system );
}

double Framework::TextZuDouble( char *c ) // Konvertiert c zu double
{
    return strtod( c, 0 );
}

float Framework::TextZuFloat( char *c ) // Konvertiert c zu double
{
    return strtof( c, 0 );
}

double Framework::TextZuDouble( char *c, char **c_ende )
{
    return strtod( c, c_ende );
}

float Framework::TextZuFloat( char *c, char **c_ende )
{
    return strtof( c, c_ende );
}

int Framework::textLength( const char *txt ) // gibt die Länge von txt zurück
{
    if( !txt )
        return 0;
    int ret = 0;
    for( ; ; ++ret )
    {
        bool br = 0;
        switch( txt[ ret ] )
        {
        case 0:
            br = 1;
            break;
        case 2:
        case 6:
            ++ret;
            break;
        case 3:
        case 4:
        case 5:
            ret += 4;
            break;
        case 8:
            ret += 4;
            break;
        }
        if( br )
            break;
    }
    return ret;
}