GStream.h

Go to the documentation of this file.

#ifndef _GSTREAM_H_

#define _GSTREAM_H_

#include "GDom.h"

LgiFunc int GStreamPrint(GStreamI *s, char *fmt, ...);

class LgiClass GStream : virtual public GStreamI, public GDom
{
public:
    virtual ~GStream() {}

    virtual int Open
    (
        char *Str = 0,
        int Int = 0
    )
    {
        return 0;
    }
    
    virtual bool IsOpen()
    {
        return false;
    }
    
    virtual int Close()
    {
        return 0;
    }

    virtual int64 GetSize() { return -1; }
    
    virtual int64 SetSize(int64 Size) { return -1; }

    virtual int64 GetPos() { return -1; }

    virtual int64 SetPos(int64 Pos) { return -1; }

    virtual int Read(void *Buffer, int Size, int Flags = 0) { return 0; }

    virtual int Write(void *Buffer, int Size, int Flags = 0) { return 0; }

    virtual GStreamI *Clone() { return 0; }

    virtual int Print(char *Format, ...);
};

class LgiClass GStreamEnd
{
public:
    virtual ~GStreamEnd() {}

    virtual void Reset() {}

    virtual int IsEnd
    (
        void *Data,
        int Len
    ) = 0;
};

class LgiClass GLinePrefix : public GStreamEnd
{
    bool Start;
    int Pos;
    char *At;
    char *Prefix;
    bool Eol;

public:
    GLinePrefix
    (
        char *p,
        bool eol = true
    );
    
    ~GLinePrefix();

    void Reset();
    int IsEnd(void *s, int Len);
};

class LgiClass GEndOfLine : public GStreamEnd
{
public:
    int IsEnd(void *s, int Len);
};

class LgiClass GStreamer
{
    int StartTime;
    int EndTime;
    int Total;
    int Size;
    char *Buf;

public:
    GStreamer
    (
        // Buffer size in bytes, 4 KB by default
        int BufSize = 4 << 10
    );
    virtual ~GStreamer();

    // Properties
    int GetRate();
    int GetTotal();
    int GetElapsedTime();
};

class LgiClass GPullStreamer : public GStreamer
{
public:
    virtual int Pull(GStreamI *Source, GStreamEnd *End = 0) = 0;
};

class LgiClass GPushStreamer : public GStreamer
{
public:
    virtual int Push(GStreamI *Dest, GStreamEnd *End = 0) = 0;
};

class LgiClass GCopyStreamer
{
public:
    virtual int Copy(GStreamI *Source, GStreamI *Dest, GStreamEnd *End = 0);
};

class LgiClass GMemStream : public GStream
{
    char *Mem;
    int64 Len, Pos, Alloc;
    bool Own;
    int GrowBlockSize;

    void _Init();

public:
    GMemStream();
    GMemStream
    (
        GStreamI *Src,
        int64 Start,
        int64 Len
    );
    GMemStream
    (
        void *Mem,
        int64 Len,
        bool Copy = true
    );
    GMemStream
    (
        int GrowBlockSize
    );

    ~GMemStream();
    bool IsOpen() { return Mem != 0; }
    int Close();
    int64 GetSize() { return Len; }
    int64 GetPos() { return Pos; }
    int64 SetPos(int64 p) { return Pos = p; }

    int Open(char *Str, int Int);
    int64 SetSize(int64 Size);

    bool IsOk();
    int Read(void *Buffer, int Size, int Flags = 0);
    int Write(void *Buffer, int Size, int Flags = 0);
    int Write(GStream *Out, int Size);
    GStreamI *Clone();
};

class LgiClass GProxyStream : public GStreamI
{
protected:
    GStreamI *s;

public:
    GProxyStream(GStreamI *p)
    {
        s = p;
    }

    int Open(char *Str, int Int)        { return s->Open(Str, Int); }
    bool IsOpen()                       { return s->IsOpen(); }
    int Close()                         { return s->Close(); }
    int64 GetSize()                     { return s->GetSize(); }
    int64 SetSize(int64 Size)           { return s->SetSize(Size); }
    int64 GetPos()                      { return s->GetPos(); }
    int64 SetPos(int64 Pos)             { return s->SetPos(Pos); }
    int Read(void *b, int l, int f = 0) { return s->Read(b, l, f); }
    int Write(void *b, int l, int f = 0) { return s->Write(b, l, f); }
    bool GetValue(char *n, GVariant &v) { return s->GetValue(n, v); }
    bool SetValue(char *n, GVariant &v) { return s->SetValue(n, v); }

    GStreamI *Clone()                   { return new GProxyStream(s); }
};

class LgiClass GTempStream : public GProxyStream
{
    GStream Null;
    int MaxMemSize;

protected:
    class GMemStream *Mem;
    class GFile *Tmp;
    char *TmpFolder;

public:
    GTempStream(char *TmpFolder = 0, int maxMemSize = 1 << 20);
    ~GTempStream();

    int GetMaxMemSize() { return MaxMemSize; }
    int Write(void *Buffer, int Size, int Flags = 0);
    void Empty();
};

#endif

---