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 );
        //! 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 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 char *( ) const;
        //! Konviertiert den Inhalt des Textes zu einer Zahl
        DLLEXPORT operator int() const;
        //! Konviertiert den Inhalt des Textes zu einer Zahl
        DLLEXPORT operator __int64() const;
        //! Konviertiert den Inhalt des Textes zu einer Kommazahl
        DLLEXPORT operator double() const;
        //! Konviertiert den Inhalt des Textes zu einer Kommazahl
        DLLEXPORT 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( 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( 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( 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( 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( 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( 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( 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( 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( 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( 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