KSG-Framework/Text.h

#ifndef Text_H
#define Text_H

#include <functional>
#include <sstream>

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

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

    namespace Regex
    {
        class Result;
        class RegexConfig;
    } // namespace Regex

    class DynamicBuffer : public std::stringbuf
    {
    private:
        std::function<int(std::stringbuf&)> onAppend;

    public:
        DLLEXPORT DynamicBuffer(std::function<int(std::stringbuf&)> onAppend);

        DLLEXPORT virtual int sync() override;
    };

    class FlushingOStream : public std::ostream
    {
    private:
        std::function<void()> onDestroy;

    public:
        DLLEXPORT FlushingOStream(
            DynamicBuffer* buffer, std::function<void()> onDestroy = []() {});
        DLLEXPORT FlushingOStream(const Framework::FlushingOStream& stream);

        DLLEXPORT ~FlushingOStream();
    };

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

        DLLEXPORT Text(char* txt, int l);

    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();

    private:
        DLLEXPORT void setTextZ(char* t, int l);

    public:
        //! 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);
        //! Gibt einen ostream zurück, der alle ausgaben an diesen Text anhängt
        DLLEXPORT FlushingOStream append();
        //! 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);
        // replaces all regular expression occurences by a static string
        // \param regex The regular expression to search for
        // \param replacement The string to replace the occurences with
        // \param config The configuration for the regular expression
        DLLEXPORT void regexReplace(const char* regex,
            const char* replacement,
            Regex::RegexConfig* config = 0);
        // replaces all regular expression occurences with a result of a
        // specified replacement function string \param regex The regular
        // expression to search for \param replacementFunction a function that
        // is called with the result of the regular expression and should return
        // the replacement string \param config The configuration for the
        // regular expression
        DLLEXPORT void regexReplace(const char* regex,
            std::function<Text(Regex::Result&)> replacementFunction,
            Regex::RegexConfig* config = 0);
        //! 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 eine bestimmte Zeichenkette vorkommt
        //! \param searchStartIndex Der index ab dem gesucht werden soll
        //! \param t Die Zeichenkette, nach der gesucht werden soll
        //! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
        DLLEXPORT bool hat(int searchStartIndex, 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 einer bestimmten Zeichenkette im Text zurück
        //! \param searchStart Index ab dem gesucht werden soll
        //! \param t Die Zeichenkette, die gefunden werden soll
        //! \return Die Position des ersten Vorkommens der Zeichenkette
        DLLEXPORT int positionVon(int searchStart, 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 const 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);
} // namespace Framework
#endif