KSG-Framework/Text.h

#ifndef Text_H
#define Text_H

#include "Reader.h"
#include "ReferenceCounter.h"

namespace Framework
{
	class Text; //! aus dieser Datei

	//! Ein ersatz für String
	class Text : public virtual ReferenceCounter
	{
	private:
		char* txt;
		char suchGBeg;
		char suchGEnd;
		int precision;

	public:
		//! Erstellt ein neues Text Objekt mit dem Wert ""
		DLLEXPORT Text();
		//! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
		//! \param txt Der Text, der kopiert werden soll
		DLLEXPORT Text(const Text& txt);
		//! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
		//! \param txt Die Zeichenkette, die kopiert werden soll
		DLLEXPORT Text(const char* txt);
		//! Erstellt ein neues Text Objekt mit einer zahl als text
		//! \param zahl Die Zahl, die im Text sein soll
		DLLEXPORT Text(int zahl);
		//! Erstellt ein neues Text Objekt mit einer zahl als text
		//! \param num Die Zahl, die im Text sein soll
		DLLEXPORT Text(double num);
		//! Erstellt ein neues Text Objekt mit einer zahl als text
		//! \param num Die Zahl, die im Text sein soll
		DLLEXPORT Text(float num);
		//! Löscht den Text
		DLLEXPORT ~Text();
		//! Wandelt alle buchstaben in großbuchstaben um
		DLLEXPORT void toUpperCase();
		//! Wandelt alle buchstaben in kleinbuchstaben um
		DLLEXPORT void toLowerCase();
		//! Legt die Suchgrenzen fest, die von den Suchfunktionen verwendet werden.
		//! \param gBeg Das Zeichen, bei dem die Suche beginnen soll
		//! \param gEnd Das Zeichen, bei dem die Suche enden soll
		DLLEXPORT void setSuchGrenzen(char gBeg, char gEnd);
		//! Setzt den Text, den das Zeichnung speichert
		//! \param t Eine Zeichenkette, deren Inhalt kopiert wird
		DLLEXPORT void setText(const char* t);
		//! Setzt den Text, den das Zeichnung speichert
		//! \param t Eine Zeichenkette, deren Inhalt kopiert wird
		//! \param l Die Länge des Textes, der aus (t) kopiert werden soll
		DLLEXPORT void setText(const char* t, int l);
		//! Setzt den Text, den das Zeichnung speichert
		//! \param t Das TextZeichnung, dessen Inahlt kopiert werden soll
		DLLEXPORT void setText(Text* t);
		//! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
		//! \param num Die Zahl, die ins Hex System umgewandelt und angehängt werden soll
		DLLEXPORT void appendHex(int num);
		//! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
		//! \param num Die Zahl, die ins Hex System umgewandelt und angehängt werden soll
		DLLEXPORT void appendHex(__int64 num);
		//! Fügt den übergebenen Buchtaben der Zeichenkette hinzu
		//! \param c Der Buchstabe, der angehängt werden soll
		DLLEXPORT void append(char c);
		//! Hängt die übergebene Zeichenkette ans Ende des Textes an
		//! \param t Die Zeichenkette, deren Kopie ans Ende des Textes angehängt werden soll
		DLLEXPORT void append(const char* t);
		//! Hängt einen Teil der übergebenen Zeichenkette ans Ende des Textes an
		//! \param t Die Zeichenkette, deren Kopie angehängt werden soll
		//! \param l Die Länge des Textabschnittes der angehängt werden soll
		DLLEXPORT void append(const char* t, int l);
		//! Hängt den Inhalt des eines Textes ans Ende des Textes an
		//! \param t Der Text, dessen Kopie ans Ende des Textes angehängt werden soll
		DLLEXPORT void append(Text* t);
		//! Hängt eine Zahl ans Ende Des Textes an
		//! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
		DLLEXPORT void append(int num);
		//! Hängt eine Zahl ans Ende Des Textes an
		//! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
		DLLEXPORT void append(__int64 num);
		//! Hängt eine Zahl ohne Vorzeichenbit am Ende des Textes an
		//! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
		DLLEXPORT void append(unsigned int num);
		//! Hängt eine Kommazahl am Ende des Textes an
		//! \param num Die Kommazahl, die am Ende des Textes angehängt werden soll
		DLLEXPORT void append(double num);
		//! Hängt eine Kommazahl am Ende des Textes an
		//! \param num Die Kommazahl, die am Ende des Textes angehängt werden soll
		DLLEXPORT void append(float num);
		//! Fügt an einer Bestimmten Stelle ein Zeichen in den Text ein
		//! \param p Die position im Text bei der das Zeichen eingefügt werden soll
		//! \param c Das Zeichen, das eingefügt werden soll
		DLLEXPORT void insert(int p, char c);
		//! Fügt an einer Bestimmten Stelle im Text eine Zeichenkette ein
		//! \param p Die position im Text bei der die Zeichenkette eingefügt werden soll
		//! \param t Die Zeichenkette, deren Kopie an eingefügt werden soll
		DLLEXPORT void insert(int p, const char* t);
		//! Fügt den Inhalt eines Textes an einer Bestimmten Stelle im Text ein
		//! \param p Die Position im Text, bei der der inhalt des Textest eingefügt werden soll
		//! \param t Der Text, dessen Kopie an der Stelle eingefügt werden soll
		DLLEXPORT void insert(int p, Text* t);
		//! Ersetzt einen bestimmten Textabschnitt mit einer anderen Zeichenkette
		//!  p1: Die Startposition des zu ersetzenden Textabschnittes
		//!  p2: Die Endposition des zu ersetzenden Textabschnittes
		//! \param t Die Zeichenkette, die an die entsprechende Stelle kopiert werden soll
		//! Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, "lt" ); ergibt: "Halt Welt"
		DLLEXPORT void ersetzen(int p1, int p2, const char* t);
		//! Ersetzt einen bestimmten Textabschnitt mit dem Inhalt eines anderen Textes
		//!  p1: Die Startposition des zu ersetzenden Textabschnittes
		//!  p2: Die Endposition des zu ersetzenden Textabschnittes
		//! \param t Der Text, dessen Inhalt an die entsprechende Stelle kopiert werden soll
		//! Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, new Text( "lt" ) ); ergibt: "Halt Welt"
		DLLEXPORT void ersetzen(int p1, int p2, Text* t);
		//! Sucht und erstetzt jedes Vorkommen eines bestimmten Buchstaben durch einen anderen
		//!  c1: Der Buchstabe der ersetzt werden soll
		//!  c2: Der Buchstabe, durch den der Andere ersetzt werden soll
		DLLEXPORT void ersetzen(char c1, char c2);
		//! Sucht und erstetzt jedes Vorkommen einer bestimmten Zeichenkette durch eine andere
		//!  t1: Die Zeichenkette, die ersetzt werden soll
		//!  t2: Die Zeichenkette, durch welche die Andere ersetzt werden soll
		DLLEXPORT void ersetzen(const char* t1, const char* t2);
		//! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch eine andere Zeichenkette
		//!  t1: Der Text, dessen Inhalt gesucht und ersetzt wird
		//!  t2: Die Zeichenkette, durch welche das Vorkommen des Textes ersetzt werden soll
		DLLEXPORT void ersetzen(Text* t1, const char* t2);
		//! Sucht und erstetzt jedes Vorkommen einer Zeichenkette durch den Inhalt eines Textes
		//!  t1: Die Zeichenkette, die ersetzt werden soll
		//!  t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette ersetzten soll
		DLLEXPORT void ersetzen(const char* t1, Text* t2);
		//! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch den Inhalt eines anderen Textes
		//!  t1: Der Text, dessen Vorkommen ersetzt werden sollen
		//!  t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette ersetzten soll
		DLLEXPORT void ersetzen(Text* t1, Text* t2);
		//! Ersetzt das i-te auftreten eines bestimmten Buchstaben mit einem anderen Buchstaben
		//! \param i Das wie vielte Auftreten des Buchstabens ersetzt werden soll
		//!  c1: Der Buchstabe, dessen i-tes Auftreten erstetzt werden soll
		//!  c2: Der Buchstabe, der das i-te Auftreten des anderen Buchstabens ersetzen soll
		DLLEXPORT void ersetzen(int i, char c1, char c2);
		//! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit einer anderen Zeichenkette
		//! \param i Das wie vielte Auftreten der Zeichenkette ersetzt werden soll
		//!  c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
		//!  c2: Die Zeichenkette, die das i-te Auftreten der anderen Zeichenkette ersetzen soll
		DLLEXPORT void ersetzen(int i, const char* t1, const char* t2);
		//! Ersetzt das i-te auftreten des Inhalts eines Textes mit einer Zeichenkette
		//! \param i Das wie vielte Auftreten des Textes ersetzt werden soll
		//!  c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
		//!  c2: Die Zeichenkette, die das i-te Auftreten des Textes ersetzen soll
		DLLEXPORT void ersetzen(int i, Text* t1, const char* t2);
		//! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit dem Inhalt eines Textes
		//! \param i Das wie vielte Auftreten der Zeichenkette ersetzt werden soll
		//!  c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
		//!  c2: Der Text, dessen Inhalt das i-te Auftreten der Zeichenkette ersetzen soll
		DLLEXPORT void ersetzen(int i, const char* t1, Text* t2);
		//! Ersetzt das i-te auftreten eines bestimmten Textes mit dem Inhalt eines anderen Textes
		//! \param i Das wie vielte Auftreten des Textes ersetzt werden soll
		//!  c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
		//!  c2: Der Text, dessen Inhalt das i-te Auftreten des anderen Textes ersetzen soll
		DLLEXPORT void ersetzen(int i, Text* t1, Text* t2);
		//! Löscht den bisherigen Text und erzeugt einen Text, der aus einem Bestimten Buchstaben besteht, mit einer bestimmten Länge
		//! \param c Der Buchstabe, aus dem der Text bestehen soll
		//! \param length Die Länge des Textes
		DLLEXPORT void fillText(char c, int length);
		//! Löscht ein Bestimmtes Zeichen aus dem Text
		//! \param p Die Position des zu löschenden Zeichens
		DLLEXPORT void remove(int p);
		//! Löscht einen Bestimmten Textabschnitt
		//!  p1: Die Startposition des zu löschenden Abschnittes
		//!  p2: Die Endposition des zu löschenden Abschnittes (Das Zeichen bei p2 bleibt erhalten)
		DLLEXPORT void remove(int p1, int p2);
		//! Löscht jedes Vorkommen eines bestimmten Buchsaben
		//! \param c Der Buchstabe, dessen Vorkommen gelöscht werden soll
		DLLEXPORT void remove(char c);
		//! Löscht jedes Vorkommen einer bestimmten Zeichenkette
		//! \param t Die Zeichenkette, deren Vorkommen entfernt werden sollen
		DLLEXPORT void remove(const char* t);
		//! Löscht jedes Vorkommen des Inhalts eines Textes
		//! \param t Der text, dessen Inhalt gelöscht werden soll
		DLLEXPORT void remove(Text* t);
		//! Löscht das i-te Vorkommen eines bestimmten Buchstaben
		//! \param i Das wie vielte Vorkommen des Buchstabens gelöscht werden soll
		//! \param c Der Buchstabe, dessen i-tes Vorkommen gelöscht werden soll
		DLLEXPORT void remove(int i, char c);
		//! Löscht das i-te Vorkommen einer bestimmten Zechenkette
		//! \param i Das wie vielte Vorkommen der Zeichenkette gelöscht werden soll
		//! \param t Die Zeichenkette, dessen i-tes Vorkommen gelöscht werden soll
		DLLEXPORT void remove(int i, const char* t);
		//! Löscht das i-te Vorkommen eines bestimmten Textinhaltes
		//! \param i Das wie vielte Vorkommen des Textinhaltes gelöscht werden soll
		//! \param t Der Text, dessen i-tes Vorkommen gelöscht werden soll
		DLLEXPORT void remove(int i, Text* t);
		//! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
		//! \param pos Die Position des ersten zeichens
		DLLEXPORT void removeWhitespaceAfter(int pos);
		//! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
		//! \param pos Die Position des ersten zeichens (beginnt bei pos-1)
		DLLEXPORT void removeWhitespaceBefore(int pos);
		//! Setzt die Anzahl der Nachkommastellen beim Anhängen von Kommazahlen
		//! \param p Die Anzahl der Stellen nach dem Komma
		DLLEXPORT void setPrecision(int p);
		//! Gibt die Länge des Textes zurück
		DLLEXPORT int getLength() const;
		//! Ermittelt die neue Curserposition nachdem Drücken der 'Links' Pfeiltaste
		//! \param pos Die alte Curserposition
		DLLEXPORT int getLKick(int pos) const;
		//! Ermittelt die neue Curserposition nachdem Drücken der 'Oben' Pfeiltaste
		//! \param pos Die alte Curserposition
		DLLEXPORT int getOKick(int pos) const;
		//! Ermittelt die neue Curserposition nachdem Drücken der 'Rechts' Pfeiltaste
		//! \param pos Die alte Curserposition
		DLLEXPORT int getRKick(int pos) const;
		//! Ermittelt die neue Curserposition nachdem Drücken der 'Unten' Pfeiltaste
		//! \param pos Die alte Curserposition
		DLLEXPORT int getUKick(int pos) const;
		//! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
		//! \param t Der Text, nach dessen Inhalt gesucht werden soll
		//! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
		DLLEXPORT bool hat(Text* t) const;
		//! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
		//! \param t Die Zeichenkette, nach der gesucht werden soll
		//! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
		DLLEXPORT bool hat(const char* t) const;
		//! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
		//! \param t Der Text, nach dessen Inhalt gesucht werden soll
		//! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
		//! \param pos die position an der die zeichenkette im string beginnen soll
		DLLEXPORT bool hatAt(int pos, Text* t) const;
		//! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
		//! \param t Die Zeichenkette, nach der gesucht werden soll
		//! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
		//! \param pos die position an der die zeichenkette im string beginnen soll
		DLLEXPORT bool hatAt(int pos, const char* t) const;
		//! Überprüft, ob im Text ein bestimmtes Zeichen vorkommt
		//! \param c Das Zeichen, nach dem gesucht werden soll
		//! \return (true), wenn das Zeichen vorkommt. (false) sonnst
		DLLEXPORT bool hat(char c) const;
		//! Überprft, ob der Text den selben Inhalt wie eine Zeichenkette hat
		//! \param t Die Zeichenkette, die verglichen werden soll
		//! \return (true), wenn der Inhalt des Textes gleich der Zeichenkette ist. (false) sonst
		DLLEXPORT bool istGleich(const char* t) const;
		//! Überprft, ob der Text den selben Inhalt wie ein anderer Text hat
		//! \param t Der Text, dessen Inhalt verglichen werden soll
		//! \return (true), wenn die Inhalte der Texte übereinstimmen. (false) sonst
		DLLEXPORT bool istGleich(Text* t) const;
		//! Gibt den Inhalt des Textes als Zeichenkette zurück
		DLLEXPORT const char* getText() const;
		//! Zählt, wie oft ein bestimmter Buchstabe im Text vorkomt
		//! \param c Der Buchstabe, der gezählt werden soll
		//! \return Die Anzahl des Buchstabens im Text
		DLLEXPORT int anzahlVon(char c) const;
		//! Zählt, wie oft eine bestimmte Zeichenkette im Text vorkommt
		//! \param t Die Zeichenkette, die gezählt werden soll
		//! \return Die Anzahl der Zeichenkette im Text
		DLLEXPORT int anzahlVon(const char* t) const;
		//! Zählt, wie oft der Inhalt eines Textest im Text vorkommt
		//! \param t Der Text, dessen Inhalt gezählt werden soll
		//! \return Die Anzahl des Textinhaltes im Text
		DLLEXPORT int anzahlVon(Text* t) const;
		//! Gibt die erste Position eines bestimmten Buchstabens im Text zurück
		//! \param c Der Buchstabe, der gefunden werden soll
		//! \return Die Position des ersten Vorkommens des Buchstabens
		DLLEXPORT int positionVon(char c) const;
		//! Gibt die erste Position einer bestimmten Zeichenkette im Text zurück
		//! \param t Die Zeichenkette, die gefunden werden soll
		//! \return Die Position des ersten Vorkommens der Zeichenkette
		DLLEXPORT int positionVon(const char* t) const;
		//! Gibt die erste Position eines Textinhaltes im Text zurück
		//! \param t Der Text, dessen Inhalt gefunden werden soll
		//! \return Die Position des ersten Vorkommens des Textinhaltes
		DLLEXPORT int positionVon(Text* t) const;
		//! Gibt die i-te Position eines bestimmten Buchstabens im Text zurück
		//! \param c Der Buchstabe, der gefunden werden soll
		//! \param i Das wievielte Vorkommen gefunden werden soll
		//! \return Die Position des i-ten Vorkommens des Buchstabens
		DLLEXPORT int positionVon(char c, int i) const;
		//! Gibt die i-te Position einer bestimmten Zeichenkette im Text zurück
		//! \param t Die Zeichenkette, die gefunden werden soll
		//! \param i Das wievielte Vorkommen gefunden werden soll
		//! \return Die Position des i-ten Vorkommens der Zeichenkette
		DLLEXPORT int positionVon(const char* t, int i) const;
		//! Gibt die i-te Position eines Textinhaltes im Text zurück
		//! \param t Der Text, dessen Inhalt gefunden werden soll
		//! \param i Das wievielte Vorkommen gefunden werden soll
		//! \return Die Position des i-ten Vorkommens des Textinhaltes
		DLLEXPORT int positionVon(Text* t, int i) const;
		//! Gibt einen Text zurück, der eine Kopie eines bestimmten Textabschnittes enthält
		//!  p1: Die Startposition des Textabschnittes
		//!  p2: Die Endposition des Textabschnittes (nicht enthalten)
		DLLEXPORT Text* getTeilText(int p1, int p2) const;
		//! Gibt einen Text zurück, der eine Kopie eines bestimmten Textabschnittes enthält
		//!  p1: Die Startposition des Textabschnittes (Der Textabschnitt geht bis ans Ende des Textes)
		DLLEXPORT Text* getTeilText(int p) const;
		// berechnet den Hash code des textes
		DLLEXPORT int hashCode() const;
		//! Hängt eine Zahl ans Ende des Textes an
		DLLEXPORT Text& operator+=(const int num);
		//! Hängt eine Zahl ans Ende des Textes an
		DLLEXPORT Text& operator+=(const __int64 num);
		//! Hängt eine Kommazahl ans Ende des Textes an
		DLLEXPORT Text& operator+=(const double num);
		//! Hängt eine Kommazahl ans Ende des Textes an
		DLLEXPORT Text& operator+=(const float num);
		//! Hängt eine Zeichenkette ans Ende des Textes an
		DLLEXPORT Text& operator+=(const char* txt);
		//! Hängt eine Kopie des Inhalts eines Textes ans Ende des Textes an
		DLLEXPORT Text& operator+=(const Text& txt);
		//! Setzt den Inhalt des Textes gleich einer Zahl
		DLLEXPORT Text& operator=(const int num);
		//! Setzt den Inhalt des Textes gleich einer Kommazahl
		DLLEXPORT Text& operator=(const double num);
		//! Setzt den Inhalt des Textes gleich einer Kommazahl
		DLLEXPORT Text& operator=(const float num);
		//! Setzt den Inahlt des Textes gleich einer Zeichenkette
		DLLEXPORT Text& operator=(const char* txt);
		//! Setzt den Inhalt des Textes gleich einer Kopie des Inhalts eines anderen Textes
		DLLEXPORT Text& operator=(const Text& txt);
		//! Gibt den Inhalt des Textes als Zeichenkette zurück
		DLLEXPORT operator const char* () const;
		//! Konviertiert den Inhalt des Textes zu einer Zahl
		DLLEXPORT explicit operator int() const;
		//! Konviertiert den Inhalt des Textes zu einer Zahl
		DLLEXPORT explicit operator __int64() const;
		//! Konviertiert den Inhalt des Textes zu einer Kommazahl
		DLLEXPORT explicit operator double() const;
		//! Konviertiert den Inhalt des Textes zu einer Kommazahl
		DLLEXPORT explicit operator float() const;
		//! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung später kommt als der Inhalt eines anderen Textes
		DLLEXPORT bool operator>(Text& t) const;
		//! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung früher kommt als der Inhalt eines anderen Textes
		DLLEXPORT bool operator<(Text& t) const;
		//! Erstellt einen neuen Text bestehend aus diesem und t2
		DLLEXPORT Text operator+(const Text& t2) const;
		//! Erstellt einen neuen Text bestehend aus diesem und t2
		DLLEXPORT Text operator+(const char* t2) const;
		//! Erstellt einen neuen Text bestehend aus diesem und num
		DLLEXPORT Text operator+(const int num) const;
		//! Erstellt einen neuen Text bestehend aus diesem und num
		DLLEXPORT Text operator+(const __int64 num) const;
		//! Erstellt einen neuen Text bestehend aus diesem und num
		DLLEXPORT Text operator+(const double num) const;
		//! Erstellt einen neuen Text bestehend aus diesem und num
		DLLEXPORT Text operator+(const float num) const;
		//! Prüft ob der Text mit dem anderen Text übereinstimmt
		DLLEXPORT bool operator==(const Text& right) const;
	};

	class TextReader : public Reader, public virtual ReferenceCounter
	{
	private:
		Text* txt;
		__int64 lPos;

	public:
		//! Konstructor
		//! \param txt Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
		DLLEXPORT TextReader(Text* txt);
		//! Destructor
		DLLEXPORT virtual ~TextReader();
		//! Setzt die Position des Bytes, das als nächstes gelesen werden soll
		//! \param pos Der Index des Bytes
		//! \param ende 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
		DLLEXPORT void setLPosition(__int64 pos, bool ende) override;
		//! Ließt aus der Datei
		//! \param bytes Ein Array, der mit Bytes aus dem Text gefüllt werden soll
		//! \param len Wie viele Bytes aus dem Text gelesen werden sollen
		DLLEXPORT void lese(char* bytes, int len) override;
		//! Ließt die nächste zeile des Textes ein
		//! \return Die gelesene Zeile als Text mit zeilenumbruch
		DLLEXPORT Text* leseZeile() override;
		//! Prüft, ob die Resource vollständig gelesen wurde
		//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
		DLLEXPORT bool istEnde() const override;
		//! 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
		DLLEXPORT __int64 getLPosition() const override;
		//! Gibt die Anzahl der zu lesenden Bytes zurück
		DLLEXPORT __int64 getSize() const override;
	};

	//! Durchsucht eine Zeichenkette nach dem num-ten Vorkommen eines bestimmten Buchstabens
	//! \param string Die zu durchsuchende Zeichenkette
	//! \param c Der zu suchende Buchstabe
	//! \param num Das wievielte Vorkommen des Buchtaben gefunden werden soll
	//! \return (-1), wenn es kein num-tes Vorkommen des Buchstaben gibt. Sonst die Position des num-ten Vorkommens in der Zeichenkette
	DLLEXPORT int stringPositionVonChar(const char* string, char c, int num); //! sucht die position des num-ten c-s in string, -1 bei nicht gefunden
	//! Durchsucht eine Zeichenkette nach einer Anderen Zeichenkette
	//! \param string Die zu durchsuchende Zeichenkette
	//! \param suche Die Zeichenkette, nach der gesucht werden soll
	//! \param sBegPos Die Position, ab der die Suche begonnen werden soll
	//! \return Die Position, an der die zu suchende Zeichenkette erstmals gefunden wurde. (-1) Wenn nichts gefunden wurde.
	DLLEXPORT int stringPositionVonString(const char* string, char* suche, int sBegPos);

	//! Kopiert eine bestimmte Zeichenkette in die Zwischenablage des Betriebssystems
	//! \param txt Die Zeichenkette, die kopiert werden soll
	DLLEXPORT void TextKopieren(const char* txt);
	//! Ermittelt, ob in der Zwischenablage des Betriebssystems eine Zeichenkette steht.
	//! \return Die Zeichenkette aus der Zwischenablage. Wenn keine Zeichenkette kopiert wurde, wird eine lehre Zeichenkette zurückgegeben.
	DLLEXPORT char* TextInsert();
	//! Wandelt einen bestimmten schreibbaren Buchstaben in einen Groß- oder Kleinbuchstaben um
	//! \param c Der Buchstabe, der umgewandelt werden soll
	//! \param groß Wenn (true), so wird der Buchstabe in einen Großbuchstaben umgewandelt. Wenn (false), wird er in einen Kleinbuchstaben umgewandelt.
	//! \return Den umgewandelten Buchstaben
	DLLEXPORT char smallOrBig(char c, bool big);
	//! Ermittelt, ob ein Buchstabe ein schreibbares Zeichen ist
	//! \param zeichen Der Buchstabe, der geprüft werden soll
	//! \return (true), wenn der Buchstabe gezeichnet werden kann. (false) sonnst
	DLLEXPORT bool istSchreibbar(unsigned char zeichen);
	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
	//! \param c Die Zeichenkette, in der Die Zahl steht
	//! \param system Die Basis der Zahl
	//! \return Die Zahl, die im Text stand
	DLLEXPORT unsigned int TextZuInt(const char* c, int system);
	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
	//! \param c Die Zeichenkette, in der Die Zahl steht
	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das nächste Zeichen in der Zeichenkette, das nach der Zah steht
	//! \param system Die Basis der Zahl
	//! \return Die Zahl, die im Text stand
	DLLEXPORT unsigned int TextZuInt(const char* c, char** c_ende, int system);
	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
	//! \param c Die Zeichenkette, in der Die Zahl steht
	//! \param system Die Basis der Zahl
	//! \return Die Zahl, die im Text stand
	DLLEXPORT unsigned __int64 TextZuInt64(const char* c, int system);
	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
	//! \param c Die Zeichenkette, in der Die Zahl steht
	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das nächste Zeichen in der Zeichenkette, das nach der Zah steht
	//! \param system Die Basis der Zahl
	//! \return Die Zahl, die im Text stand
	DLLEXPORT unsigned __int64 TextZuInt64(const char* c, char** c_ende, int system);
	//! Konvertiert eine Zeichenkette zu einem Double
	//! \param c Die Zeichenkette, die konvertiert werden soll
	//! \return Das double, was in der Zeichenkette stand
	DLLEXPORT double TextZuDouble(const char* c);
	//! Konvertiert eine Zeichenkette zu einem Float
	//! \param c Die Zeichenkette, die konvertiert werden soll
	//! \return Das float, was in der Zeichenkette stand
	DLLEXPORT float TextZuFloat(const char* c);
	//! Konvertiert eine Zeichenkette zu einem Double
	//! \param c Die Zeichenkette, die konvertiert werden soll
	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf das nächste Zeichen nach dem Double in der Zeichenkette
	//! \return Das double, was in der Zeichenkette stand
	DLLEXPORT double TextZuDouble(const char* c, char** c_ende);
	//! Konvertiert eine Zeichenkette zu einem float
	//! \param c Die Zeichenkette, die konvertiert werden soll
	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf das nächste Zeichen nach dem float in der Zeichenkette
	//! \return Das float, was in der Zeichenkette stand
	DLLEXPORT float TextZuFloat(const char* c, char** c_ende);
	//! Ermittelt die Länge einer bestimmten Zeichenkette
	//! \param txt Die Zeichenkette, deren Länge ermittelt werden soll
	//! \return Die Länge der Zeichenkette
	DLLEXPORT int textLength(const char* txt);
}
#endif