KSG-Framework/DateiSystem.h

#ifndef DateiSystem_H
#define DateiSystem_H

#include <fstream>

#include "Array.h"
#include "Punkt.h"

namespace Framework
{
    class Bild;    //! Bild.h
    class Text;    //! Text.h
    class FBalken; //! Fortschritt.h
#ifdef WIN32
    class Buchstabe; //! Schrift.h
    class Alphabet;  //! Schrift.h
    class Schrift;   //! Schrift.h
#endif
    class LTDBPixel; //! from this file
    class LTDBKopf;  //! from this file
    class LTDBBody;  //! from this file
    class LTDBDatei; //! from this file
    class LTDSPixel; //! from this file
#ifdef WIN32
    class LTDSDateiKopf;        //! from this file
    class LTDSSchriftKopf;      //! from this file
    class LTDSBuchstabenKopf;   //! from this file
    class LTDSBuchstabenKoerper; //! from this file
    class LTDSDatei;            //! from this file
#endif

    //! LTDB File format --- Used for storing multiple images in one file.

    //! Used for storing and loading a single pixel from an image in the
    //! LTDB file format
    class LTDBPixel : public virtual ReferenceCounter //! Pixel of an LTDB file
    {
    private:
        LTDBPixel* davor; //! Previous pixel
        char index;       //! Bit length of the pixel
        char iR, iG, iB, iA;
        char miR, miG, miB, miA;
        char maxIndex;    //! Length of the pixel
        bool change  : 1; //! Whether something changes in the following 5 variables
        bool changeR : 1; //! Whether Red changes
        bool changeG : 1; //! Whether Green changes
        bool changeB : 1; //! Whether Blue changes
        bool changeA : 1; //! Whether Alpha changes
        unsigned char komp : 3; //! Compression of color values
        unsigned char R;        //! Red
        unsigned char G;        //! Green
        unsigned char B;        //! Blue
        unsigned char A;        //! Alpha
        bool addBitZuFarbe(
            unsigned char bit); //! Adds a bit to the color values
        bool getNextFarbeBit(
            char& byte, int i); //! Stores the next color bit in byte

    public:
        //! Constructor
        //! \param davor The pixel that was loaded before. 0 if this is the
        //! first pixel
        DLLEXPORT LTDBPixel(LTDBPixel* davor);
        //! Destructor
        DLLEXPORT ~LTDBPixel();
        //! For loading. Adds some bits to the pixel
        //! \param byte The last byte read from the file
        //! \param begin The index of the first bit in byte where the pixel begins
        //! \return The index of the bit in byte where the pixel ended. -1 if
        //! the pixel is not finished at the end of the byte
        DLLEXPORT char addByte(char byte, char begin);
        //! For saving. Sets the color to be stored in the pixel
        //! \param f The color to store
        DLLEXPORT void setFarbe(int f);
        //! Compresses the pixel. Must be called before saving.
        DLLEXPORT void komprimieren();
        //! Returns a part of the bits that represent the pixel
        //! \param byte A reference to the byte to be saved next
        //! \param begin The index of the first bit in the byte where the pixel
        //! should be stored \return The index of the bit where the pixel ends.
        //! -1 if the pixel must continue in the next byte
        DLLEXPORT char getNextByte(char& byte, int begin);
        //! Returns the color value of the pixel
        DLLEXPORT int zuFarbe() const;
        //! Returns whether the red component changed compared to the previous pixel
        DLLEXPORT bool getChangeR() const;
        //! Returns whether the green component changed compared to the previous pixel
        DLLEXPORT bool getChangeG() const;
        //! Returns whether the blue component changed compared to the previous pixel
        DLLEXPORT bool getChangeB() const;
        //! Returns whether the alpha component changed compared to the previous pixel
        DLLEXPORT bool getChangeA() const;
        //! Returns the compression of the pixel
        DLLEXPORT unsigned char getKomp() const;
        //! Returns the red component of the pixel's color
        DLLEXPORT unsigned char getR() const;
        //! Returns the green component of the pixel's color
        DLLEXPORT unsigned char getG() const;
        //! Returns the blue component of the pixel's color
        DLLEXPORT unsigned char getB() const;
        //! Returns the alpha component of the pixel's color
        DLLEXPORT unsigned char getA() const;
    };

    //! The header of the LTDB file format. Stores information about all
    //! saved images
    class LTDBDateiKopf : public virtual ReferenceCounter
    {
    private:
        RCArray<Text>* bilder;
        Array<__int64>* pos;
        int bAnzahl;

    public:
        //! Constructor
        DLLEXPORT LTDBDateiKopf();
        //! Destructor
        DLLEXPORT ~LTDBDateiKopf();
        //! Removes an image from the file header
        //! \param i The index of the image to remove
        DLLEXPORT void removeBild(int i);
        //! Removes an image from the file header
        //! \param txt The name of the image to remove
        DLLEXPORT void removeBild(Text* txt);
        //! Adds an image to the file header
        //! \param txt The name of the image
        DLLEXPORT void addBild(Text* txt);
        //! Sets the byte index in the file where the image begins
        //! \param i The index of the image
        //! \param pos The position of the image in the file
        DLLEXPORT void setBildPos(int i, __int64 pos);
        //! Sets the byte index in the file where the image begins
        //! \param txt The name of the image
        //! \param pos The position of the image in the file
        DLLEXPORT void setBildPos(Text* txt, __int64 pos);
        //! Loads the file header of an LTDB file
        //! \param f A pointer to a progress bar to use for loading. Can be 0.
        //! \param inF The opened ifstream of the LTDB file with the read
        //! position already pointing to the first byte of the file header.
        DLLEXPORT void laden(FBalken* f, std::ifstream* inF);
        //! Saves the file header to an LTDB file
        //! \param outF The opened ofstream of the LTDB file with the write
        //! position already pointing to the first byte of the file header.
        DLLEXPORT void speichern(std::ofstream* outF) const;
        //! Returns the name of a specific image
        //! \param i The index of the image whose name should be returned
        //! \return The name of the image
        DLLEXPORT Text* getBild(int i) const;
        //! Returns the name of a specific image
        //! \param i The index of the image whose name should be returned
        //! \return The name of the image without increased reference counter
        DLLEXPORT Text* zBild(int i) const;
        //! Returns the index of the first byte of an image in the file
        //! \param txt The name of the image whose start should be found
        //! \return -1 if the image was not found.
        DLLEXPORT __int64 getBildPosition(Text* txt) const;
        //! Returns the index of the first byte of an image in the file.
        //! If the index does not exist, std::out_of_range is thrown.
        //! \param index The index of the image whose start should be found
        DLLEXPORT __int64 getBildPosition(int index) const;
        //! Returns the index of a specific image
        //! \param txt The name of the image
        //! \return -1 if the image was not found
        DLLEXPORT int getBildIndex(Text* txt) const;
        //! Returns the number of images in the file
        DLLEXPORT int getbAnzahl() const;
        //! Returns a list of images in the file without increased reference
        //! counter. The list should not be modified
        DLLEXPORT RCArray<Text>* zBildListe() const;
    };

    //! Die im LTDB Dateikopf gespeicherten Informationen fuer ein einzelnes Bild
    class LTDBKopf : public virtual ReferenceCounter
    {
    private:
        __int64 a; //! Det LTDB Dateikopf ist maximal 104 Bits lang
        __int32 b; //! - bis zu 75 Bits fuer den Titel
        __int8 c;  //! - 12 Bits fuer breite

    public:
        //! Konstruktor
        DLLEXPORT LTDBKopf();
        //! Laehdt die Informationen ueber ein Bild
        //! \param f Der geoeffnette und an die richtiege Stelle zeigende
        //! ifstream der LTDB Datei
        DLLEXPORT void laden(std::ifstream* f);
        //! Setzt die Informationen die gespeichert werden sollen
        //! \param titel Der Titel des Bildes
        //! \param size Die Groesse des Bildes
        //! \return Die Anzahl der Buchstaben aus dem Titel, die im LTDB
        //! Dateiformat nicht gespeichert werden koennen. Erlaubt ist nur a-z und
        //! A-Z und ae ue oe ss und AE UE OE und . Alle grossbuchstaben im Titel werden
        //! in Kleinbuchstaben umgewandelt
        DLLEXPORT int Init(Text* titel, const Punkt& size);
        //! Laehd informationen aus geladenen Bits. Wird von der laden(
        //! std::ifstream ) Funktion verwendet. \param BeginBit Der Index des
        //! ersten Bits, welches ausgewertet werden soll \param EndBit Der Index
        //! des letzten Bits, welches nichtmehr ausgewertet werden soll \param
        //! bits Die Bits, von denen alle von BeginBit bis EndBit ausgewertet
        //! werden sollen Insgesamt muessen 104 Bits gesetzt werden. Hierauf
        //! bezihen sich BeginBit und EndBit
        DLLEXPORT void setBits(int BeginBit, int EndBit, __int16 bits);
        //! Speichert die Informationen in eine Datei
        //! \param f Der geoeffnete und an die richtiege Stelle zeigende ofstream
        //! der LTDB Datei
        DLLEXPORT void speichern(std::ofstream* f) const;
        //! Gibt die Laenge des Titels zurueck
        DLLEXPORT int getTitelLength() const;
        //! Gibt den Titel des Bildes zurueck
        DLLEXPORT Text* getTitel() const;
        //! Gibt die Groesse des Bildes zurueck
        DLLEXPORT Punkt getSize() const;
        //! Gibt die naechsten zu speichernden Bits zurueck
        //! \param begin Der Index des ersten Bits, in das gespeichert werden
        //! soll \param end Der Index des letzten Bits, in das gespeichert
        //! werden soll \return 16 Bits, in denen die Informationen zwischen
        //! begin und end stehen Insgesamt muessen 104 Bits gelesen werden.
        //! Hierauf bezihen sich BeginBit und EndBit
        DLLEXPORT __int16 getBits(int begin, int end) const;
    };

    //! Verwaltet die Pixeldaten eines einzelnen Bildes einer LTDB Datei
    class LTDBBody : public virtual ReferenceCounter
    {
    private:
        Punkt gr;
        Bild* b;
        int dateiSize;

    public:
        //! Konstruktor
        DLLEXPORT LTDBBody();
        //! Konstruktor
        //! \param k Der LTDB Kopf des Bildes, der Informationen ueber die Groesse
        //! des Bildes enthaelt
        DLLEXPORT LTDBBody(LTDBKopf* k);
        //! Destruktor
        DLLEXPORT ~LTDBBody();
        //! Setzt die Informationen ueber die Groesse des Bildes. Wird zum Laden
        //! benoetigt. \param k Der LTDB Kopf des Bildes
        DLLEXPORT void init(LTDBKopf k);
        //! Setzt die Informationen ueber die Groesse des Bildes. Wird zum Laden
        //! benoetigt. \param k Der LTDB Kopf des Bildes
        DLLEXPORT void init(LTDBKopf* k);
        //! Laedt die Pixeldaten aus der Datei
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        //! \param inF Der geoeffnete und an die richtiege Stelle zeigende
        //! ifstream der LTDB Datei
        DLLEXPORT void laden(FBalken* zF, std::ifstream* inF);
        //! Setzt das Bild, welches gespeichert werden soll
        //! \param b Das zu speichernde Bild
        DLLEXPORT void setBild(Bild* b);
        //! Speichert die Pixeldaten des Bildes in einer LTDB Datei
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        //! \param outF Der geoeffnete und an die richtiege Stelle zeigende
        //! ofstream der LTDB Datei
        DLLEXPORT void speichern(FBalken* zF, std::ofstream* outF) const;
        //! Gibt das geladene Bild zurueck
        DLLEXPORT Bild* getBild() const;
        //! Gibt die Groesse des Bildes zurueck
        DLLEXPORT const Punkt& getSize() const;
    };

    //! Verwaltet eine LTDB Datei
    class LTDBDatei : public virtual ReferenceCounter
    {
    private:
        Text* pfad;
        LTDBDateiKopf* datKpf;

    public:
        //! Konstruktor
        DLLEXPORT LTDBDatei();
        //! Destruktor
        DLLEXPORT ~LTDBDatei();
        //! Setzt den Pfad zu Datei
        //! \param pfad Der Pfad
        DLLEXPORT void setDatei(Text* pfad);
        //! Erstellt eine neue LTDB Datei
        DLLEXPORT void erstellen();
        //! Liesst grundlegende Informationen aus der Datei.
        //! Wird benoetigt, bevor mit der Datei gearbeitet wird
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        DLLEXPORT void leseDaten(FBalken* zF);
        //! Loescht die LTDB Datei
        DLLEXPORT void remove();
        //! Loescht ein Bild aus der LTDB Datei
        //! \param zF Ein Fortschrittsbalken der 0 sein kann
        //! \param name Der Name des zu loeschenden Bildes
        DLLEXPORT void remove(FBalken* zF, Text* name);
        //! Laedt ein Bild aus der LTDB Datei
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        //! \param name Der Name des Bildes, welches geladen werden soll
        //! \return Das geladene Bild. 0, falls das Bild nicht gefunden wurde
        DLLEXPORT Bild* laden(FBalken* zF, Text* name);
        //! Speichert ein neues Bild in der LTDB Datei
        //! \param zF Ein Fortscrittsbalken, der 0 sein kann
        //! \param bild Das Bild, welches geloescht werden soll
        //! \param name Der Name, unter dem das Bild gespeichert werden soll
        //! \return Anzahl der Warnungen, die beim Konvertieren des Namens in
        //! einen gueltigen Namen aufgetreten sind. -1, falls bereis ein Bild mit
        //! dem selben Namen existiert
        DLLEXPORT int speichern(FBalken* zF, Bild* bild, Text* name);
        //! Gibt eine Liste mit gespeicherten Bildern zurueck
        //! Die Liste sollte nicht veraendert werden
        DLLEXPORT RCArray<Text>* zBildListe();
        //! Gibt den Pfad zur LTDB Datei zurueck
        DLLEXPORT Text* getPfad() const;
        //! Gibt die Anzahl der Bilder in der LTDB Datei zurueck
        DLLEXPORT int getBildAnzahl() const;
        //! Prueft, ob die LTDB Datei existiert
        DLLEXPORT bool istOffen() const;
    };

#ifdef WIN32
    //! LTDS Dateivormat --- Dient zum speichern von Schriftarten

    //! Verwaltet einen einzelnen Pixel von einem Buchstaben
    class LTDSPixel : public virtual ReferenceCounter
    {
    private:
        char index;
        char iA;
        char miA;
        char maxIndex; //! Laenge des Pixels
        bool aender;
        bool aenderA;
        unsigned char komp : 3; //! Komprimierung der Farbwerte
        unsigned char alpha;
        LTDSPixel* davor;
        bool addBitZuFarbe(
            unsigned char bit); //! Fuegt den Farbwerten ein Bit hinzu
        bool getNextFarbeBit(
            char& byte, int i); //! Speichert das naechste Farbbit in byte

    public:
        //! Konstruktor
        //! \param davor Der Pixel, der vor diesem geladen wurde. 0, fals diess
        //! der erste Pixel ist
        DLLEXPORT LTDSPixel(LTDSPixel* davor);
        //! Destruktor
        DLLEXPORT ~LTDSPixel();
        //! Fuegt dem Pixel einiege geladene Bits hinzu. Zum Laden gedacht.
        //! \param byte Das letzte aus der Datei geladene Byte.
        //! \param begin Der Index des ersten Bits im Byte, wo der Pixel beginnt
        //! \return Der Index des Letzten Bits in Byte, wo der Pixel aufhoehrt.
        //! -1, falls der Pixel im naechsten Byte weitergeht
        DLLEXPORT char addByte(char byte, char begin);
        //! Setzt den Alpha Wert des Pixels. Zum speichern gedacht.
        //! \param alpha Der Alpha Wert des Pixels.
        DLLEXPORT void setAlpha(unsigned char alpha);
        //! Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
        DLLEXPORT void Komp();
        //! Gibt ein Teil der Bits zurueck, die den Pixel representieren
        //! \param byte Eine Referens auf das Byte, dass als naechstes
        //! gespeichert werden soll \param begin Der Index des ersten Bits im zu
        //! speichernden Byte, wo der Pixel gespeichert werden soll \return Der
        //! Index des Bits im zu speichernden Byte, wo der Pixel aufhoehrt. -1,
        //! falls der Pixel im naechsten Byte fortgesetzt werden muss
        DLLEXPORT char getNextByte(char& byte, int bbegin);
        //! Gibt die Komprimierung des Pixels zurueck
        DLLEXPORT unsigned char getKomp() const;
        //! Gibt zurueck, ob sich der Alpha Wert im Vergleich zu dem Pixel davor
        //! geaendert hat
        DLLEXPORT bool getAEnderA() const;
        //! Gibt den Alpha Wert des Pixels zurueck
        DLLEXPORT unsigned char getA() const;
    };

    //! Verwaltet den Kopf einer LTDS Datei. Er enthaelt Informationen ueber die
    //! in der Datei gespeicherten Schriftgroessen
    class LTDSDateiKopf : public virtual ReferenceCounter
    {
    private:
        unsigned char sganzahl;
        unsigned char* gr;
        int* pos;

    public:
        //! Konstruktor
        DLLEXPORT LTDSDateiKopf();
        //! Destruktor
        DLLEXPORT ~LTDSDateiKopf();
        //! Laedt den Kopf aus der LTDS Datei
        //! \param inF Der geoeffnete und an die richtige Stelle zeigende
        //! ifstream der LTDS Datei
        DLLEXPORT void laden(std::ifstream* inF);
        //! Fuegt eine Schriftgroesse hinzu
        //! \param sg Die Schriftgroesse, die hinzugefuegt werden soll
        DLLEXPORT void addSG(char sg);
        //! Loescht eine Schriftgroesse
        //! \param sg Die Schriftgroesse, die geloescht werden soll
        DLLEXPORT void removeSG(char sg);
        //! Speichert den LTDS Kopf in der Datei
        //! \param outF Der geoeffnete und an die richtiege Stelle zeigende
        //! ofstream der LTDS Datei
        DLLEXPORT void speichern(std::ofstream* outF) const;
        //! Gibt einen Array von gespeicherten Schriftgroessen zurueck
        //! Der Array sollte nicht veraedert werden
        DLLEXPORT unsigned char* getSchriftGroesseList() const;
        //! Gibt einen Array mit positionen der ersten Bytes fuer jede
        //! Schriftgroesse aus der Datei zurueck
        DLLEXPORT int* getPositionList() const;
        //! Gibt die Anzahl der gespeicherten Schriftgroessen zurueck
        DLLEXPORT int getSchriftGroesseAnzahl() const;
    };

    //! Der Kopf einer Schriftgroesse. Enthaelt Informationen ueber die
    //! gespeicherten Zeichen
    class LTDSSchriftKopf : public virtual ReferenceCounter
    {
    private:
        unsigned char schriftSize;
        unsigned char* zeichen;
        int* pos;
        unsigned char zeichenAnzahl;

    public:
        //! Konstruktor
        DLLEXPORT LTDSSchriftKopf();
        //! Destruktor
        DLLEXPORT ~LTDSSchriftKopf();
        //! Laedt den Kopf einer Schriftgroesse aus der Datei
        //! \param inF Der geoeffnete und an de richtiege Stelle zeigende
        //! ifstream der LTDS Datei
        DLLEXPORT void laden(std::ifstream* inF);
        //! Setzt die Schriftgroesse. Zum speichern gedacht
        //! \param gr Die Schriftgroesse
        DLLEXPORT void setSchriftgroesse(unsigned char gr);
        //! Setzt das Alphabet, welches in der Schriftgroesse gespeichert werden
        //! soll \param alphabet Das Alphabet, welches alle zu speichernden
        //! Zeichen in der Schriftgroesse enthaelt
        DLLEXPORT void setZeichenAlphabet(Alphabet* alphabet);
        //! Fuegt der Schriftgroesse ein Zeichen hinzu, welches gespeichert werden
        //! soll \param zeichen Der ASCII code des Zeichens, welches hinzugefuegt
        //! werden soll
        DLLEXPORT void addZeichen(unsigned char zeichen);
        //! Loescht ein Zeichen aus der Schriftgroesse
        //! \param zeich Der ASCII code des Zeichens, welches geloescht werden
        //! soll
        DLLEXPORT void removeZeichen(unsigned char zeich);
        //! Speichert den Kopf der Schriftgroesse in der LTDS Datei
        //! \param outF Der geoeffnete und an die richtiege Stelle zeigende
        //! ofstream der LTDS Datei
        DLLEXPORT void speichern(std::ofstream* outF) const;
        //! Gibt die Schriftgroesse zurueck, zu der dieser Kopf gehoehrt
        DLLEXPORT unsigned char getSchriftGroesse() const;
        //! Gibt die Anzahl der in der Schriftgroesse gespeicherten Zeichen zurueck
        DLLEXPORT unsigned char getZeichenAnzahl() const;
        //! Gibt einen Array mit den Positionen der ersten Bytes von den
        //! gespeicherten Zeichen aus der LTDS Datei zurueck
        DLLEXPORT int* getPositionen() const;
        //! Gibt einen Array mit den ASCII codes der Gespeicherten Zeichen
        //! zurueck
        DLLEXPORT unsigned char* getZeichen() const;
    };

    //! Der Kopf eines einzelnen Zeichens aus der LTDS Datei. Enthaelt
    //! informationen ueber die Pixelgroesse des Zeichens
    class LTDSBuchstabenKopf : public virtual ReferenceCounter
    {
    private:
        unsigned char zeichen;
        Punkt size;

    public:
        //! Konstruktor
        DLLEXPORT LTDSBuchstabenKopf();
        //! Laedt die Daten aus der LTDS Datei
        //! \param inF Der geoeffnete und an die richtiege Stelle zeigende
        //! ifstream der LTDS Datei
        DLLEXPORT void laden(std::ifstream* inF);
        //! Setzt die Daten, die gespeichert werden sollen.
        //! \param zeichen Der ASCII code des Zeichens
        //! \param groesse Die Groesse des Zeichens in Pixeln
        DLLEXPORT void init(unsigned char zeichen, const Punkt& groesse);
        //! Setzt die Daten, die gespeichert werden sollen.
        //! \param zeichen Der ASCII code des Zeichens
        //! \param br Die Breite des Zeichens in Pixeln
        //! \param hoe Die Hoehe des Zeichens in Pixeln
        DLLEXPORT void init(unsigned char zeichen, int br, int hoe );
        //! Speichert die Daten in der LTDS Datei
        //! \param outF Der geoeffnete und auf die richtiege Stelle zeigende
        //! ofstream der LTDS Datei
        DLLEXPORT void speichern(std::ofstream* outF) const;
        //! Gibt den ASCII code des Zeichens zurueck
        DLLEXPORT unsigned char getZeichen() const;
        //! Gibt die Breite des Zeichens in Pixeln zurueck
        DLLEXPORT int getBreite() const;
        //! Gibt die Hoehe des Zeichens in Pixeln zurueck
        DLLEXPORT int getHoehe() const;
        //! Gib t die Groesse des Zeichens in Pixeln zurueck
        DLLEXPORT const Punkt& getGroesse() const;
    };

    //! Verwaltet die Pixeldaten eines Zeichens
    class LTDSBuchstabenKoerper : public virtual ReferenceCounter
    {
    private:
        Punkt size;
        unsigned char zeichen;
        Buchstabe* buchstabe;

    public:
        //! Konstruktor
        //! \param kopf Der Kopf des Zeichens
        DLLEXPORT LTDSBuchstabenKoerper(LTDSBuchstabenKopf * kopf);
        //! Destruktor
        DLLEXPORT ~LTDSBuchstabenKoerper();
        //! Setzt den Buchstaben, der gespeichert werden soll
        //! \param zeichen Der zu speichernde Buchstabe
        DLLEXPORT void setBuchstabe(Buchstabe * zeichen);
        //! Laedt die Pixel aus der LTDS Datei
        //! \param inF Der geoeffnete und auf die richtiege Stelle zeigende
        //! ifstream der LTDS Datei
        DLLEXPORT void laden(std::ifstream * inF);
        //! Speichert die Pixel in die LTDS Datei
        //! \param outF der geoeffnete und an die richtiege Stelle zeigende
        //! ofstream der LTDS Datei
        DLLEXPORT void speichern(std::ofstream * outF) const;
        //! Gibt den geladenen Buchstaben zurueck
        DLLEXPORT Buchstabe* getBuchstabe() const;
        //! Gibt den ASCII code des Buchstabens zurueck
        DLLEXPORT unsigned char getZeichen() const;
    };

    //! Verwaltet eine LTDS Datei
    class LTDSDatei : public virtual ReferenceCounter
    {
    private:
        Text* pfad;
        LTDSDateiKopf* dateiKopf;

    public:
        //! Konstruktor
        DLLEXPORT LTDSDatei();
        //! Destruktor
        DLLEXPORT ~LTDSDatei();
        //! Setzt den Pfad zur Datei
        //! \param txt Der Pfad
        DLLEXPORT void setPfad(Text* txt);
        //! Laedt wichtiege Informationen aus der Datei. Muss vor dem Verwenden
        //! der Datei aufgerufen werden
        DLLEXPORT void leseDaten();
        //! Fuegt der Datei eine Schriftgroesse hinzu, fals diese noch nicht
        //! existiert \param alphabet Das Alphabet, welches die Zeichen in der
        //! gewuenschten Schriftgroe0e enthaelt
        DLLEXPORT void addSchriftgroesse(Alphabet* alphabet);
        //! Fuegt einer Schriftgroesse einen Buchstaben hinzu
        //! \param gr Die Schriftgroesse des Buchstabens
        //! \param zeich Der Buchstabe, der gespeichert werden soll
        //! \param zeichen Der ASCII code des Buchstabens
        DLLEXPORT void addBuchstabe(
            int gr, Buchstabe* zeich, unsigned char zeichen);
        //! Loescht eine bestimmte Schriftgroesse aus der Datei
        //! \param gr Die Schriftgroesse, die entfernt werden soll
        DLLEXPORT void loescheSchrifrGroesse(int gr);
        //! Loescht einen Buchstaben aus einer Schriftgroesse
        //! \param gr Die Schriftgroesse, aus der der Buchstabe entfernt werden
        //! soll \param zeichen Der ASCII code des Zeichens, welches geloescht
        //! werden soll
        DLLEXPORT void loescheBuchstabe(int gr, unsigned char zeichen);
        //! Loescht die LTDS Datei
        DLLEXPORT void loescheDatei();
        //! Erstellt die LTDS Datei
        DLLEXPORT void erstelleDatei();
        //! Speichert eine gesammte Schrift in der Datei
        //! \param schrift Die schrift, die gespeichert werden soll
        DLLEXPORT void speicherSchrift(Schrift* schrift);
        //! Laedt die gesammte Schrift aus der Datei
        //! \return Die geladene Schrift. 0, falls ein Fehler beim Laden
        //! aufgetreten ist
        DLLEXPORT Schrift* ladeSchrift();
        //! Laedt eine einzelne Schriftgroesse aus der Datei
        //! \param schriftgroesse Die zu ladende Schriftgroesse
        //! \return Ein Alphabet mit den Zeichen in der Schriftgroesse. 0, falls
        //! die Schriftgroesse nicht gefunden wurde
        DLLEXPORT Alphabet* ladeAlphabet(int schriftgroesse);
        //! Laedt ein bestimmtes Zeichen einer bestimmten Schriftgroesse
        //! \param schriftgroesse Die Schriftgroesse, zu dem das Zeichen gehoert
        //! \param zeichen Der ASCII code des zu ladenden Zeichens
        //! \return Der geladene Buchstabe. 0, falls das Zeichen nicht gefunden
        //! wurde.
        DLLEXPORT Buchstabe* ladeBuchstabe(
            int schriftgroesse, unsigned char zeichen);
        //! Gibt den Pfad zur LTDS Datei zurueck
        DLLEXPORT Text* getPfad() const;
        //! Gibt die Anzahl der gespeicherten Schriftgroessen zurueck
        DLLEXPORT int getAnzahlSchriftgroessen() const;
        //! Gibt einen Array mit den gespeicherten Schriftgroessen zurueck
        //! Der Array sollte nicht veraendert werden
        DLLEXPORT unsigned char* getSchriftGroessen() const;
        //! Gibt die Anzahl an gespeicherten Zeichen in einer Schriftgroesse
        //! zurueck \param sg Die Schriftgroesse, von der die Anzahl der ZEichen
        //! ermittelt werden soll \return Die Anzahl der Zeichen.
        DLLEXPORT unsigned char getAnzahlBuchstaben(int sg);
        //! Gibt einen Array mit Buchstaben einer bestimmten Schriftgroesse zurueck
        //! \param sg Die Schriftgroesse
        //! \return Der Array mit den ASCII codes der Zeichen. 0, falls die
        //! Schriftgroesse nicht gefunden wurde.
        DLLEXPORT unsigned char* getBuchstaben(int sg);
    };
#endif
    //! Bit Funktionen

    //! gibt 1-bits in gewinschter anzahl zurueck.
    //! \param a Die Anzahl der Bits, die 1 sein sollen
    //! \return 32 Bits, wobei die einser Bits von rechts beginnen
    DLLEXPORT int Bits(int a);
    //! Gibt zurueck, wie viele Bits benoetigt werden um eine Zahl darzustellen
    //! \param c Die Zahl, die dargestellt werden soll
    //! \return Die Anzahl der benoetigten Bits
    DLLEXPORT int getBits(char c);
} // namespace Framework
#endif