KSG-Framework/Text.cpp

//---Include---
#include "Text.h"
#include <sstream>
#include <iomanip>
#include <math.h>
#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::appendHex(__int64 num) // hängt die zahl in hex anden Text an
{
	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(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 << std::fixed << num;
	append(ss.str().c_str());
}

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
}

// 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;
}

const 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;
}

// 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 const 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();
	const 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();
	const 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;
}

bool Text::operator==(const Text& right) const
{
	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()
{
	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(&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(const 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(const 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(const 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(const 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(const char* c, int system)
{
	if (system == 16)
		return strtoull(c, 0, system);
	return (unsigned __int64)strtoll(c, 0, system);
}

unsigned __int64 Framework::TextZuInt64(const 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(const char* c) // Konvertiert c zu double
{
	return strtod(c, 0);
}

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

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

float Framework::TextZuFloat(const 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;
}