GContainers.h

Go to the documentation of this file.

#ifndef _CONTAIN_H_
#define _CONTAIN_H_

#include "LgiInc.h"
#include "LgiOsDefs.h"
#include "GStream.h"

class DLinkList;
class DLinkInterator;

typedef int (*ListSortFunc)(void*, void*, int);

class LgiClass DLinkList
{
    friend class DLinkIterator;
    friend class Item;

protected:
    int Items;
    class Item *FirstObj, *LastObj;
    class ItemIter *Cur;

    ItemIter GetIndex(int Index);
    ItemIter GetPtr(void *Ptr, int &Base);

public:
    DLinkList();
    virtual ~DLinkList();

    bool IsValid();

    int Length() { return Items; }
    virtual void Empty();
    void *operator [](int Index);
    DLinkList &operator =(DLinkList &lst);

    bool Delete();
    bool Delete(int Index);
    bool Delete(void *p);
    bool Insert(void *p, int Index = -1);
    void *Current();
    void *First();
    void *Last();
    void *Next();
    void *Prev();
    int IndexOf(void *p);
    bool HasItem(void *p);
    void *ItemAt(int i);
    void Sort(ListSortFunc Compare, int Data);
};

class LgiClass DLinkIterator
{
protected:
    DLinkList *List;
    class ItemIter *Cur;

public:
    DLinkIterator(DLinkList *list);
    ~DLinkIterator();

    void *operator [](int Index);
    void *Current();
    void *First();
    void *Last();
    void *Next();
    void *Prev();
    bool HasItem(void *p);
    int IndexOf(void *p);
    int Length();
};

template <class Type>
class List : public DLinkList
{
public:
    virtual bool Delete()           { return DLinkList::Delete(); }
    virtual bool Delete(int i)      { return DLinkList::Delete(i); }
    virtual bool Delete(Type *p)    { return DLinkList::Delete((void*)p); }
    virtual bool Insert
    (
        Type *p,
        int Index = -1
    )
    { return DLinkList::Insert((void*)p, Index); }

    /*
    virtual void Insert
    (
        List<Type> &l,
        int Index = -1
    )
    {
        for (Type *p = l.First(); p; p = l.Next())
        {
            if (Index >= 0) DLinkList::Insert(p, Index++);
            else DLinkList::Insert(p);
        }
    }
    */
    
    Type *First()                   { return (Type*) DLinkList::First(); }
    Type *Last()                    { return (Type*) DLinkList::Last(); }
    Type *Next()                    { return (Type*) DLinkList::Next(); }
    Type *Prev()                    { return (Type*) DLinkList::Prev(); }
    Type *Current()                 { return (Type*) DLinkList::Current(); }
    Type *operator [](int Index)    { return ((Type*) ((*((DLinkList*)this))[Index])); }
    
    int IndexOf(Type *p)            { return DLinkList::IndexOf((void*)p); }
    bool HasItem(Type *p)           { return DLinkList::HasItem((void*)p); }
    Type *ItemAt(int i)             { return (Type*) DLinkList::ItemAt(i); }
    void Sort
    (
        int (*Compare)(Type *a, Type *b, int data),
        int Data
    )
    { DLinkList::Sort( (int (*)(void *a, void *b, int data)) Compare, Data); }
    
    void DeleteObjects()
    {
        for (Type *o=(Type*)DLinkList::First(); o; o=(Type*)DLinkList::Next())
        {
            DeleteObj(o);
        }
        DLinkList::Empty();
    }
    void DeleteArrays()
    {
        for (Type *o=(Type*)DLinkList::First(); o; o=(Type*)DLinkList::Next())
        {
            DeleteArray(o);
        }
        DLinkList::Empty();
    }

    List &operator =
    (
        List<Type> &lst
    )
    {
        DLinkList *l = this;
        *l = (DLinkList&)lst;
        return *this;
    }
};

template <class Type>
class Iterator : public DLinkIterator
{
public:
    Iterator
    (
        DLinkList *l
    ) : DLinkIterator(l) {}
    ~Iterator() {}

    Type *operator [](int Index) { return (Type*) (* (DLinkIterator*)this)[Index]; }
    Type *First() { return (Type*) DLinkIterator::First(); }
    Type *Last() { return (Type*) DLinkIterator::Last(); }
    Type *Next() { return (Type*) DLinkIterator::Next(); }
    Type *Prev() { return (Type*) DLinkIterator::Prev(); }
    Type *Current() { return (Type*) DLinkIterator::Current(); }
    bool HasItem(Type *p) { return DLinkIterator::HasItem((Type*)p); }
    int IndexOf(Type *p) { return DLinkIterator::IndexOf((Type*)p); }
};

class LgiClass GBytePipe : public GStream
{
protected:
    struct Block
    {
        int Next;
        int Used;
        int Size;
        uchar *Ptr() { return (uchar*) (this + 1); }

        Block()
        {
            Next = 0;
            Size = 0;
            Used = 0;
        }
    };

    int PreAlloc;
    List<Block> Mem;

public:
    GBytePipe
    (
        int PreAlloc = 0
    );
    virtual ~GBytePipe();

    virtual bool IsEmpty() { return Mem.Length() == 0; }
    virtual void Empty();
    virtual void *New
    (
        int AddBytes = 0
    );
    virtual int Peek
    (
        uchar *Ptr,
        int Size
    );

    int64 GetSize();
    int Read(void *Buffer, int Size, int Flags = 0);
    int Write(void *Buffer, int Size, int Flags = 0);

    int Pop(short &i);
    int Pop(int &i);
    int Pop(double &i);

    int Push(short i)               { return Write((uchar*)&i, sizeof(i)); }
    int Push(int i)                 { return Write((uchar*)&i, sizeof(i)); }
    int Push(double i)              { return Write((uchar*)&i, sizeof(i)); }
};

class LgiClass GStringPipe : public GBytePipe
{
public:
    GStringPipe
    (
        int PreAlloc = -1
    ) : GBytePipe(PreAlloc) {}
    
    ~GStringPipe() {}

    virtual int Pop
    (
        char *Str,
        int BufSize
    );
    virtual int Push
    (
        char *Str,
        int Len=-1
    );
    virtual int Push
    (
        char16 *Str,
        int Len = -1
    );

    bool Printf(char *Str, ...);
    bool Printf(char16 *Str, ...);
    
    char *NewStr();
    char16 *NewStrW();
};

LgiFunc uint LgiHash
(
    uchar *In,
    int Len,
    bool Case       
);

class GHashEntry;

class LgiClass GHashTable
{
    class GHashTablePrivate *d;

public:
    GHashTable
    (
        int Size = 0,
        bool Case = true
    );
    
    GHashTable
    (
        List<char> &strs
    );
    
    virtual ~GHashTable();

    void Set
    (
        List<char> &strs
    );

    int64 GetSize();
    
    void SetSize(int64 s);
    
    bool GetStringPool();
    
    void SetStringPool(bool b);
    
    bool IsCase();

    void IsCase(bool c);
    
    bool IsOk();

    int Length();

    bool Add
    (
        char *Key,
        void *Value = (void*)1
    );
    
    bool Delete
    (
        char *Key
    );
    
    void *Find(char *Key);
    
    void *First(char **Key = 0);
    
    void *Current(char **Key = 0);
    
    void *Next(char **Key = 0);

    void Empty();

    int64 Sizeof();
};

#endif

---