U_LISTS.H

gehe zur Dokumentation dieser Datei

//#############################################################################
//                                                                           //
// U_LISTS.H                                                                 //
// Subsystem: Utilities - verkettete Listen                                  //
// Benutung durch andere Subsysteme erforderlich: JA                         //
// Implementation: U_LISTS.CPP                                               //
//---------------------------------------------------------------------------//
// Autoren: Thomas Kullmann, Günther Reinecker                               //
// Stand:   02.04.2004                                                       //
//                                                                           //
//#############################################################################

#ifndef __U_LISTS_H
#define __U_LISTS_H

#include "utils\u_values.h" // für _CURVECLASS, _FREEOBJ, Trace

//##############################################################################
// TLnkContainer
//##############################################################################

// Kontainer zum Verketten von void* -Elementen als doppelt verkettete Liste
// Zugriff nur durch dieses Subsystem
class TLnkContainer {
        friend class TLnkList;
        friend class TIndList;

private:
        TLnkContainer(void *const aData, TLnkList &aList);

        // ==> stimmen <aList> und <m_List> überein ?
        bool IsElementOf(const TLnkList *const aList) const;

// ATTRIBUT(E)
private:
        void *const m_Data;

        TLnkList &m_List;

        TLnkContainer *m_Prev;
        TLnkContainer *m_Next;
};

//##############################################################################
// TLnkList
//##############################################################################

// doppelt verkettete Liste
// Zugriff nur über Container und dieses Subsystem
class _CURVECLASS TLnkList {
private:
        TLnkList(const TLnkList& aList) : m_FailIfNull(aList.m_FailIfNull), m_FailIfExists(aList.m_FailIfExists), m_AutoDelete(aList.m_AutoDelete), m_First(0), m_Last(0) {}; // kein Copy-Konstruktor
        TLnkList &operator= (const TLnkList&) { return *this; }; // kein Zuweisungsoperator

public:
        TLnkList(bool aFailIfNull= true, bool aFailIfExists= true, bool aAutoDelete= false);
        virtual  ~TLnkList();

        // gibt das Element aus dem Container zurück
        // (1) wenn <m_AutoDelete>==true darf das Element nicht selbst mit delete freigegeben werden!
        // ==> das im Container verpackte Element 
        void *GetAt(TLnkContainer &aContainer) const;

        // fügt <aData> am Anfang der Liste ein
        // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
        // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
        // ==> wurde <aData> eingefügt
        //     bei (1) und (2) ist der Rückgabewert false
        bool Insert(void *const aData);

        // fügt <aData> am Ende der Liste ein
        // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
        // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
        // ==> wurde <aData> eingefügt
        //     bei (1) und (2) ist der Rückgabewert false
        bool Append(void *const aData);

        // fügt <aData> VOR <aContainer> ein
        // (0) wenn <aContainer>==0 wird am Anfang der Liste eingefügt - siehe Insert
        // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
        // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
        // ==> wurde <aData> eingefügt
        //     bei (1) und (2) ist der Rückgabewert false
        bool InsBefore(TLnkContainer *aContainer, void *const aData);

        // fügt <aData> NACH <aContainer> ein
        // (0) wenn <aContainer>==0 wird am Ende der Liste eingefügt - siehe Append
        // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
        // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
        // ==> wurde <aData> eingefügt
        //     bei (1) und (2) ist der Rückgabewert false
        bool AddAfter(TLnkContainer *aContainer, void *const aData);

        // entfernt <aContainer>
        // (1) wenn <m_AutoDelete>==true und das in <aContainer> liegende Non-Null-Element einzigartig in der Liste ist, wird das Element entfernt und mit delete freigegeben
        // ==> das entfernte Element
        //     bei (1) ist der Rückgabewert 0
        void *Remove(TLnkContainer &aContainer);

        // entfernt alle Element aus der Liste
        // bei <m_AutoDelete>==true werden die Non-Null-Elemente mit delete freigegeben
        virtual void Clear();

        // entfernt <aContainer> und Folgeelemente
        // bei <m_AutoDelete>==true werden einzigartige Non-Null-Elemente mit delete freigegeben
        void CutList(TLnkContainer &aContainer);

private:
        // sucht nach dem nächsten Container, der <aData> beinhaltet - die Suche beginnt bei <aStart>
        // ist <aStart>==0, beginnt die Suche am Anfang
        // ==> der gefundene Container; ggf. 0
        TLnkContainer *Find(void *aData, TLnkContainer *aStart=0);

// ATTRIBUT(E)
protected:
        const bool m_FailIfNull; // Null-Elemente dürfen nicht eingefügt werden
        const bool m_FailIfExists; // Elemente dürfen nicht mehrfach eingefügt werden
        const bool m_AutoDelete; // Non-Null-Elemente mit delete freigeben, wenn letztes Vorkommen mit Remove bzw. Clear entfernt wird

        TLnkContainer *m_First;
        TLnkContainer *m_Last;
};

//##############################################################################
// TIndList
//##############################################################################

typedef unsigned long TIndex;

// Liste von void* -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
// ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
class _CURVECLASS TIndList : protected TLnkList {
public:
        TIndList(bool aFailIfNull= true, bool aFailIfExists= true, bool aAutoDelete= false);

        // (0) Bei einem zu großen Index wird das letzte Element zurückgegeben.***
        // (E) Ist die Liste leer, wird 0 zurückgegeben.***
        // <aValid> wird true gesetzt, wenn <aIndex> gültig ist und die Liste nicht leer ist; sonst false.
        // ==> das Element an Position <aIndex> 
        void *GetAt(TIndex aIndex, bool &aValid) const;
        
        // WIEVOR, jedoch ohne aValid - d.h. ein zu großer Index oder eine leere Liste sind für den Aufrufer nicht nachvollziehbar
        void *GetAt(TIndex aIndex) const;       
        void *operator[] (TIndex aIndex) const;

        // fügt <aData> am Anfang bzw. am Ende der Liste ein
        bool Insert(void *const aData);
        bool Append(void *const aData);

        // fügt <aData> VOR dem Element an Position <aIndex> ein
        // (E) Bei einem zu großen Index oder einer leeren Liste wird am Ende eingefügt.***
        // (1) und (2) und Rückgabewert gelten von TLnkList::InsBefore
        bool InsBefore(TIndex aIndex, void *const aData);

        // fügt <aData> NACH dem Element an Position <aIndex> ein
        // (E) Bei einem zu großen Index oder einer leeren Liste wird am Ende eingefügt.***
        // (1) und (2) und Rückgabewert gelten von TLnkList::AddAfter
        bool AddAfter(TIndex aIndex, void *const aData);

        // entfernt das Element an Position <aIndex>
        // (0) Bei einem zu großen Index wird das letzte Element entfernt.***
        // (E) Ist die Liste leer, wird nur 0 zurückgegeben.***
        // (1) und Rückgabewert gelten von TLnkList::Remove
        void *Remove(TIndex aIndex);

        // sucht das Element <aData>
        // (0) Ist <aData> nicht in der Liste, wird 0 zurückgegeben.***
        // (E) Ist die Liste leer, wird nur 0 zurückgegeben.***
        // (1) und Rückgabewert gelten von TLnkList::Remove
        void *RemoveData(void *aData);

        // entfernt das Element an Position <aIndex> und alle Folgeelemente
        // (E) Bei einem zu großen Index oder einer leeren Liste wird keine Aktion ausgeführt.***
        void CutList(TIndex aSize);

        // wie TLnkList::Clear
        virtual void Clear();

        // ==> Anzahl der Elemente
        TIndex GetCount() const;

private:
        // ==> der Container an Position <aIndex>
        // (0) Bei einem zu großen Index wird in der RELEASE-Version das letzte Element zurückgegeben.***
        // (E) Ist die Liste leer, wird 0 zurückgegeben.***
        TLnkContainer *Find(TIndex aIndex) const;

// ATTRIBUT(E)
protected:
        TIndex m_Count;
};

//##############################################################################
// TIntList
//##############################################################################

// Liste von int -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
// ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
class _CURVECLASS TIntList : protected TIndList {
public:
        // erzeugt eine Liste mit <aSize> leeren Elementen, deren Wert <aDefaultValue> entspricht
        TIntList(const TIndex &aSize= 0, const int &aDefaultValue= 0);

        TIntList(const TIntList &aList); // Copy-Konstruktor, die eine neue Liste mit den gleichen Elementen erzeugt
        TIntList &operator= (const TIntList &aList); // Zuweisungsoperator, der eine neue Liste mit den gleichen Elementen erzeugt

        // (E) Bei einem zu großen Index oder wenn die Liste leer ist, wird <m_DefaultValue> zurückgegeben.***
        // <aValid> wird true gesetzt, wenn <aIndex> gültig ist und die Liste nicht leer ist; sonst false.
        // ==> das Element an Position <aIndex> 
        int GetAt(const TIndex &aIndex, bool &aValid) const;
        
        // WIEVOR, jedoch ohne aValid - d.h. es ein zu großer Index oder eine leere Liste sind für den Aufrufer nicht nachvollziehbar, es wird nur <m_DefaultValue> zurückgegeben
        int GetAt(const TIndex &aIndex) const;  

        // Lesezugriff: 
        //   wie GetAt(...)
        // Schreibzugriff: 
        //   (E) Bei einem zu großen Index oder wenn die Liste leer ist, wird kein Wert gesetzt.***
        //       Dazu wird eine Kopie von <m_DefaultValue> zurückgegeben. Diese kann geändert werden, hat aber keine Wirkung auf andere Elemente der Liste oder <m_DefaultValue> selbst.
        int &operator[] (const TIndex &aIndex);

        // setzt <aValue> als Element an Position <aIndex>
        // (E) Bei einem zu großen Index oder wenn die Liste leer ist, wird kein Wert gesetzt.***
        // ==> wurde der Wert gesetzt
        bool SetAt(const TIndex &aIndex, const int &aValue);

        // fügt <aValue> am Anfang bzw. am Ende der Liste ein
        bool Insert(const int &aValue);
        bool Append(const int &aValue);

        // fügt <aValue> VOR bzw. NACH dem Element an Position <aIndex> ein
        bool InsBefore(const TIndex &aIndex, const int &aValue);
        bool AddAfter(const TIndex &aIndex, const int &aValue);

        // ändert die Größe der Liste auf <aSize>, indem entweder <aDefaultValue> am Ende eingefügt werden ODER die letzten Elemente entfernt werden
        void SetCount(const TIndex &aSize, const int &aDefaultValue);
        
        // wie SetCount(aSize, m_DefaultValue)
        void SetCount(const TIndex &aSize);

        // Element entfernen; Größe ermitteln
        TIndList::Remove;
        TIndList::Clear;
        TIndList::GetCount;

private:
        int m_DefaultValue;
};

//##############################################################################
// TFloatList
//##############################################################################

// Liste von float -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
// Beschreibung siehe TIntList
class _CURVECLASS TFloatList : protected TIndList {
public:
        TFloatList(const TIndex &aSize= 0, const float &aDefaultValue= 0.0);
        TFloatList(const TFloatList &aList); 
        TFloatList &operator= (const TFloatList &aList); 

        float GetAt(const TIndex &aIndex, bool &aValid) const;
        float GetAt(const TIndex &aIndex) const;        
        float &operator[] (const TIndex &aIndex);
        bool SetAt(const TIndex &aIndex, const float &aValue);

        bool Insert(const float &aValue);
        bool Append(const float &aValue);

        bool InsBefore(const TIndex &aIndex, const float &aValue);
        bool AddAfter(const TIndex &aIndex, const float &aValue);

        void SetCount(const TIndex &aSize, const float &aDefaultValue);
        void SetCount(const TIndex &aSize);

        // Element entfernen; Größe ermitteln
        TIndList::Remove;
        TIndList::Clear;
        TIndList::GetCount;

private:
        float m_DefaultValue;
};

//##############################################################################
// TPoint
//##############################################################################

class _CURVECLASS TPoint {
public:
        TPoint();
        TPoint(const TPoint &aPoint); 
        TPoint &operator= (const TPoint &aPoint);

        // Direktzugriff auf Pt
        float GetAt(const TIndex &aIndex, bool &aValid) const;
        float GetAt(const TIndex &aIndex) const;        
        float &operator[] (const TIndex &aIndex);
        bool SetAt(const TIndex &aIndex, const float &aValue);

        TFloatList Pt;
        BOOL Valid;
};

//##############################################################################
// TPointList
//##############################################################################

// Liste von TPoint -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
// Beschreibung siehe TIntList
class _CURVECLASS TPointList : protected TIndList {
public: 
        TPointList(const TIndex &aSize= 0, TPoint *aDefaultValue= 0);
        TPointList(const TPointList &aList); 
        TPointList &operator= (const TPointList &aList); 

        TPoint &GetAt(const TIndex &aIndex, bool &aValid) const;
        TPoint &GetAt(const TIndex &aIndex) const;      
        TPoint &operator[] (const TIndex &aIndex) const;

        bool Insert(const TPoint &aValue);
        bool Append(const TPoint &aValue);

        bool InsBefore(const TIndex &aIndex, const TPoint &aValue);
        bool AddAfter(const TIndex &aIndex, const TPoint &aValue);

        void SetCount(const TIndex &aSize, const TPoint &aDefaultValue);
        void SetCount(const TIndex &aSize);

        // Element entfernen; Größe ermitteln
        TIndList::Remove;
        TIndList::Clear;
        TIndList::GetCount;

private:
        TPoint m_DefaultValue;
};

/* Anwendungsbeispiel1:
        TPointList plist(0); // Liste soll erstmal Länge 0 haben (keine Punkte enthalten)
        // Punkt dynamisch erzeugen und initailisieren
        TPoint *pkt1= new TPoint();
        pkt1->Pt.SetAt(0, 2);
        pkt1->Pt.SetAt(1, 4);
        pkt1->Pt.SetAt(2, 6);
        pkt1->Valid= TRUE;
        // Punkt ans Listenende (weil vorher leer, nun das einigste Element)
        plist.Append(*pkt1);
        delete pkt1; // können wir nun freigeben, beim Einfügen von Punkten werden diese KOPIERT!
        // Punkt auf Stack erzeugen, wird am Ende des Blockes automatisch vom Programm freigegeben
        TPoint pkt2;
        pkt2.Pt.SetAt(0, 1);
        pkt2.Pt.SetAt(1, 2);
        pkt2.Pt.SetAt(2, 3);
        pkt2.Valid= FALSE;
        plist.Append(pkt2); // pkt2 wird von Append kopiert, können wir also weiterverwenden
        // und deshalb verwenden wir pkt2 noch einmal
        pkt2.Pt.SetAt(0, 4);
        pkt2.Pt.SetAt(1, 5);
        pkt2.Pt.SetAt(2, 6);
        pkt2.Valid= TRUE;
        plist.Append(pkt2);
        // jetzt ändern wir nochmal, direkt in der Liste
        plist[0].Pt.SetAt(1, 7); // wir entscheiden uns um und setzen Koordinate #1 von pkt1 statt auf 4 (siehe oben) jetzt auf 7
        plist[1].Pt.SetAt(2, 99); // und hier wird Koordinate #2 von pkt2 geändert, von 3 auf 99
        // Mal sehen was angekommen ist: Koordinate #0 sollte immernoch 2 sein
        //                                          #1 haben wir ja auch 7 geändert
        TraceMsg( plist[0].Pt[0] );
        TraceMsg( plist[0].Pt[1] );
        //                               Koordinate #0 ist 1
        //                                          #2 geändert auf 99
        TraceMsg( plist[1].Pt[0] );
        TraceMsg( plist[1].Pt[2] );
        //                               Koordinate #1 ist 5
        //                                          #2 ist 6
        TraceMsg( plist[2].Pt[1] );
        TraceMsg( plist[2].Pt[2] );
        // alle dynamisch erzeugten Punkte, die in plist eingefügt werden, werden automatisch im Destruktor zerstört
*/

/* Anwendungsbeispiel2:
        TPointList plist(10); // Liste soll erstmal Länge 10 haben (Punkte #0..#9)
        for (int j= 0; j<10; j++) {
                plist[j].Pt.SetAt(0, 3*j);
                plist[j].Pt.SetAt(1, 3*j + 1);
                plist[j].Pt.SetAt(2, 3*j + 2);
                plist[j].Valid= j % 2; // ständjger Wechsel von Valid zwischen 0 und 1
        }
        // Mal sehen was angekommen ist: Berechnungen stammen aus der for-Schleife - hinten stehen die prognostizierten Ausgaben
        j= 0;
        TraceMsg( plist[j].Pt[0] ); // 3*j    = 3*0    = 0
        TraceMsg( plist[j].Pt[1] ); // 3*j + 1= 3*0 + 1= 1
        TraceMsg( plist[j].Valid ); // j % 2  = 0 % 2  = 0
        j= 3;
        TraceMsg( plist[j].Pt[0] ); // 3*j    = 3*3    = 9
        TraceMsg( plist[j].Pt[2] ); // 3*j + 2= 3*3 + 2= 11
        TraceMsg( plist[j].Valid ); // j % 2  = 3 % 2  = 1
        j= 9;
        TraceMsg( plist[j].Pt[1] ); // 3*j + 1= 3*9 + 1= 28
        TraceMsg( plist[j].Pt[2] ); // 3*j + 2= 3*9 + 2= 29
        TraceMsg( plist[j].Valid ); // j % 2  = 9 % 2  = 1
        // alle enthaltenen Punkte, werden automatisch im Destruktor zerstört
*/

#endif // __U_LISTS_H

---