|
|
@@ -12,1637 +12,1653 @@ using namespace Framework;
|
|
|
// inhalt der Text Klasse aus Text.h
|
|
|
// Konstruktor
|
|
|
Text::Text()
|
|
|
- : ReferenceCounter(),
|
|
|
- txt( 0 ),
|
|
|
- suchGBeg( 0 ),
|
|
|
- suchGEnd( 0 ),
|
|
|
- precision( 0 )
|
|
|
+ : ReferenceCounter(),
|
|
|
+ txt(0),
|
|
|
+ suchGBeg(0),
|
|
|
+ suchGEnd(0),
|
|
|
+ precision(0)
|
|
|
{
|
|
|
- setText( "" );
|
|
|
+ setText("");
|
|
|
}
|
|
|
|
|
|
-Text::Text( const Text &txt )
|
|
|
- : Text()
|
|
|
+Text::Text(const Text& txt)
|
|
|
+ : Text()
|
|
|
{
|
|
|
- setText( txt );
|
|
|
+ setText(txt);
|
|
|
}
|
|
|
|
|
|
-Text::Text( const char *t )
|
|
|
- : Text()
|
|
|
+Text::Text(const char* t)
|
|
|
+ : Text()
|
|
|
{
|
|
|
- setText( t ); // Text setzen
|
|
|
+ setText(t); // Text setzen
|
|
|
}
|
|
|
|
|
|
-Text::Text( int zahl )
|
|
|
- : Text()
|
|
|
+Text::Text(int zahl)
|
|
|
+ : Text()
|
|
|
{
|
|
|
- *this = zahl;
|
|
|
+ *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()
|
|
|
+Text::Text(double num)
|
|
|
+ : Text()
|
|
|
{
|
|
|
- *this = num;
|
|
|
+ *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()
|
|
|
+Text::Text(float num)
|
|
|
+ : Text()
|
|
|
{
|
|
|
- *this = num;
|
|
|
+ *this = num;
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
Text::~Text()
|
|
|
{
|
|
|
- delete[]txt;
|
|
|
+ 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;
|
|
|
- }
|
|
|
- }
|
|
|
+ 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;
|
|
|
- }
|
|
|
- }
|
|
|
+ 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
|
|
|
+void Text::setSuchGrenzen(char gBeg, char gEnd) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
|
|
|
{
|
|
|
- suchGBeg = gBeg;
|
|
|
- suchGEnd = gEnd;
|
|
|
+ suchGBeg = gBeg;
|
|
|
+ suchGEnd = gEnd;
|
|
|
}
|
|
|
|
|
|
-void Text::setText( const char *t ) // ersetzt den Text
|
|
|
+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
|
|
|
+ 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
|
|
|
+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
|
|
|
+ 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 )
|
|
|
+void Text::setText(Text* t)
|
|
|
{
|
|
|
- setText( t->getText() ); // Text setzen
|
|
|
- t->release(); // übergabe loslassen
|
|
|
+ setText(t->getText()); // Text setzen
|
|
|
+ t->release(); // übergabe loslassen
|
|
|
}
|
|
|
|
|
|
-void Text::append( char c ) // hängt an den Text an
|
|
|
+void Text::append(char c) // hängt an den Text an
|
|
|
{
|
|
|
- append( &c, 1 );
|
|
|
+ append(&c, 1);
|
|
|
}
|
|
|
|
|
|
-void Text::append( const char *t ) // hängt an den Text an
|
|
|
+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
|
|
|
+ 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
|
|
|
+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;
|
|
|
+ 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
|
|
|
+void Text::appendHex(__int64 num) // hängt die zahl in hex anden 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
|
|
|
+ int l = getLength();
|
|
|
+ char* res = new char[(__int64)l + 17];
|
|
|
+ for (int i = 0; i < l; ++i)
|
|
|
+ res[i] = txt[i];
|
|
|
+ std::stringstream stream;
|
|
|
+ stream << std::setfill('0') << std::setw((int)sizeof(__int64) * 2) << std::hex << num;
|
|
|
+ std::string str = stream.str();
|
|
|
+ for (int i = l; i < l + 16; ++i)
|
|
|
+ res[i] = str.c_str()[i - l];
|
|
|
+ res[l + 16] = 0;
|
|
|
+ setText(res);
|
|
|
+ delete[] res;
|
|
|
}
|
|
|
|
|
|
-void Text::append( Text *t )
|
|
|
+void Text::append(const char* t, int l) // hängt an den Text an
|
|
|
{
|
|
|
- if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
|
|
|
- append( t->getText() ); // Text anhängen
|
|
|
- t->release(); // Übergabe loslassen
|
|
|
+ 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( int num )
|
|
|
+void Text::append(Text* t)
|
|
|
{
|
|
|
- std::stringstream ss;
|
|
|
- ss << num;
|
|
|
- append( ss.str().c_str() );
|
|
|
+ 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 )
|
|
|
+void Text::append(__int64 num)
|
|
|
{
|
|
|
- std::stringstream ss;
|
|
|
- ss << num;
|
|
|
- append( ss.str().c_str() );
|
|
|
+ std::stringstream ss;
|
|
|
+ ss << num;
|
|
|
+ append(ss.str().c_str());
|
|
|
}
|
|
|
|
|
|
-void Text::append( unsigned int num )
|
|
|
+void Text::append(unsigned int num)
|
|
|
{
|
|
|
- std::stringstream ss;
|
|
|
- ss << num;
|
|
|
- append( ss.str().c_str() );
|
|
|
+ std::stringstream ss;
|
|
|
+ ss << num;
|
|
|
+ append(ss.str().c_str());
|
|
|
}
|
|
|
|
|
|
-void Text::append( double num )
|
|
|
+void Text::append(double num)
|
|
|
{
|
|
|
- std::stringstream ss;
|
|
|
- ss.precision( precision );
|
|
|
- ss << std::fixed << num;
|
|
|
- append( ss.str().c_str() );
|
|
|
+ std::stringstream ss;
|
|
|
+ ss.precision(precision);
|
|
|
+ ss << std::fixed << num;
|
|
|
+ append(ss.str().c_str());
|
|
|
}
|
|
|
|
|
|
-void Text::append( float num )
|
|
|
+void Text::append(float num)
|
|
|
{
|
|
|
- std::stringstream ss;
|
|
|
- ss.precision( precision );
|
|
|
- ss << std::fixed << 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
|
|
|
+ std::stringstream ss;
|
|
|
+ ss.precision(precision);
|
|
|
+ ss << std::fixed << 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 )
|
|
|
+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 );
|
|
|
+ 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 )
|
|
|
+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 );
|
|
|
+ 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
|
|
|
+void Text::setPrecision(int p) // setzt die Anzahl der Nachkommastellen bei doubles
|
|
|
{
|
|
|
- precision = p;
|
|
|
+ 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;
|
|
|
+ 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 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;
|
|
|
+ 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
|
|
|
+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
|
|
|
}
|
|
|
|
|
|
// berechnet den Hash code des textes
|
|
|
int Text::hashCode() const
|
|
|
{
|
|
|
- int result = 0;
|
|
|
- int len = getLength();
|
|
|
- for( int i = 0; i < len; i++ )
|
|
|
- result += (int)pow( txt[ i ] * 31, len - 1 - i );
|
|
|
- return result;
|
|
|
+ int result = 0;
|
|
|
+ int len = getLength();
|
|
|
+ for (int i = 0; i < len; i++)
|
|
|
+ result += (int)pow(txt[i] * 31, len - 1 - i);
|
|
|
+ return result;
|
|
|
}
|
|
|
|
|
|
// Operatoren
|
|
|
-Text &Text::operator+=( const int num )
|
|
|
+Text& Text::operator+=(const int num)
|
|
|
{
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
// Hängt eine Zahl ans Ende des Textes an
|
|
|
-Text &Text::operator+=( const __int64 num )
|
|
|
+Text& Text::operator+=(const __int64 num)
|
|
|
{
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator+=( const double num )
|
|
|
+Text& Text::operator+=(const double num)
|
|
|
{
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator+=( const float num )
|
|
|
+Text& Text::operator+=(const float num)
|
|
|
{
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator+=( const char *txt )
|
|
|
+Text& Text::operator+=(const char* txt)
|
|
|
{
|
|
|
- append( txt );
|
|
|
- return *this;
|
|
|
+ append(txt);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator+=( const Text &txt )
|
|
|
+Text& Text::operator+=(const Text& txt)
|
|
|
{
|
|
|
- append( txt.getText() );
|
|
|
- return *this;
|
|
|
+ append(txt.getText());
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator=( const int num )
|
|
|
+Text& Text::operator=(const int num)
|
|
|
{
|
|
|
- setText( "" );
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ setText("");
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator=( const double num )
|
|
|
+Text& Text::operator=(const double num)
|
|
|
{
|
|
|
- setText( "" );
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ setText("");
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator=( const float num )
|
|
|
+Text& Text::operator=(const float num)
|
|
|
{
|
|
|
- setText( "" );
|
|
|
- append( num );
|
|
|
- return *this;
|
|
|
+ setText("");
|
|
|
+ append(num);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator=( const char *txt )
|
|
|
+Text& Text::operator=(const char* txt)
|
|
|
{
|
|
|
- setText( txt );
|
|
|
- return *this;
|
|
|
+ setText(txt);
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text &Text::operator=( const Text &txt )
|
|
|
+Text& Text::operator=(const Text& txt)
|
|
|
{
|
|
|
- setText( txt.getText() );
|
|
|
- return *this;
|
|
|
+ setText(txt.getText());
|
|
|
+ return *this;
|
|
|
}
|
|
|
|
|
|
-Text::operator char *( ) const
|
|
|
+Text::operator char* () const
|
|
|
{
|
|
|
- return txt;
|
|
|
+ return txt;
|
|
|
}
|
|
|
|
|
|
Text::operator int() const
|
|
|
{
|
|
|
- if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
|
|
|
- return TextZuInt( ( txt + 2 ), 16 );
|
|
|
- return TextZuInt( txt, 10 );
|
|
|
+ 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 );
|
|
|
+ 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 );
|
|
|
+ return TextZuDouble(txt);
|
|
|
}
|
|
|
|
|
|
Text::operator float() const
|
|
|
{
|
|
|
- return TextZuFloat( txt );
|
|
|
+ return TextZuFloat(txt);
|
|
|
}
|
|
|
|
|
|
-bool Text::operator>( Text &t ) const
|
|
|
+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;
|
|
|
+ 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
|
|
|
+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;
|
|
|
+ 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
|
|
|
+Text Text::operator+(const Text& t2) const
|
|
|
{
|
|
|
- return Text( *this ) += t2;
|
|
|
+ return Text(*this) += t2;
|
|
|
}
|
|
|
|
|
|
// Erstellt einen neuen Text bestehend aus diesem und t2
|
|
|
-Text Text::operator+( const char *t2 ) const
|
|
|
+Text Text::operator+(const char* t2) const
|
|
|
{
|
|
|
- return Text( *this ) += t2;
|
|
|
+ return Text(*this) += t2;
|
|
|
}
|
|
|
|
|
|
// Erstellt einen neuen Text bestehend aus diesem und num
|
|
|
-Text Text::operator+( const int num ) const
|
|
|
+Text Text::operator+(const int num) const
|
|
|
{
|
|
|
- return Text( *this ) += num;
|
|
|
+ return Text(*this) += num;
|
|
|
}
|
|
|
|
|
|
// Erstellt einen neuen Text bestehend aus diesem und num
|
|
|
-Text Text::operator+( const __int64 num ) const
|
|
|
+Text Text::operator+(const __int64 num) const
|
|
|
{
|
|
|
- return Text( *this ) += num;
|
|
|
+ return Text(*this) += num;
|
|
|
}
|
|
|
|
|
|
// Erstellt einen neuen Text bestehend aus diesem und num
|
|
|
-Text Text::operator+( const double num ) const
|
|
|
+Text Text::operator+(const double num) const
|
|
|
{
|
|
|
- return Text( *this ) += num;
|
|
|
+ return Text(*this) += num;
|
|
|
}
|
|
|
|
|
|
// Erstellt einen neuen Text bestehend aus diesem und num
|
|
|
-Text Text::operator+( const float num ) const
|
|
|
+Text Text::operator+(const float num) const
|
|
|
{
|
|
|
- return Text( *this ) += num;
|
|
|
+ return Text(*this) += num;
|
|
|
}
|
|
|
|
|
|
-bool Text::operator==( const Text &right ) const
|
|
|
+bool Text::operator==(const Text& right) const
|
|
|
{
|
|
|
- return istGleich( right );
|
|
|
+ return istGleich(right);
|
|
|
}
|
|
|
|
|
|
|
|
|
// Inhalt der TextReader Klasse
|
|
|
// Konstructor
|
|
|
// txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
|
|
|
-TextReader::TextReader( Text *txt )
|
|
|
- : ReferenceCounter()
|
|
|
+TextReader::TextReader(Text* txt)
|
|
|
+ : ReferenceCounter()
|
|
|
{
|
|
|
- this->txt = txt;
|
|
|
- lPos = 0;
|
|
|
+ this->txt = txt;
|
|
|
+ lPos = 0;
|
|
|
}
|
|
|
|
|
|
// Destructor
|
|
|
TextReader::~TextReader()
|
|
|
{
|
|
|
- txt->release();
|
|
|
+ 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 )
|
|
|
+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;
|
|
|
+ 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 )
|
|
|
+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;
|
|
|
+ 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()
|
|
|
+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;
|
|
|
+ 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();
|
|
|
+ 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;
|
|
|
+ return lPos;
|
|
|
}
|
|
|
|
|
|
//! Gibt die Anzahl der zu lesenden Bytes zurück
|
|
|
__int64 TextReader::getSize() const
|
|
|
{
|
|
|
- return txt->getLength();
|
|
|
+ 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;
|
|
|
+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
|
|
|
+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();
|
|
|
+ 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
|
|
|
+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;
|
|
|
+ if (!OpenClipboard(0))
|
|
|
+ return "";
|
|
|
+ HANDLE hClipData = GetClipboardData(CF_TEXT);
|
|
|
+ char* cBuffer = (char*)GlobalLock(hClipData);
|
|
|
+ GlobalUnlock(hClipData);
|
|
|
+ CloseClipboard();
|
|
|
+ return cBuffer;
|
|
|
#else
|
|
|
- return 0;
|
|
|
+ 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;
|
|
|
+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;
|
|
|
}
|
Kolja Strohm