Stream.hpp

Idź do dokumentacji tego pliku.

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif
#ifndef COMMON_STREAM_H_
#define COMMON_STREAM_H_

namespace common
{


extern const size_t BUFFER_SIZE;

void _ThrowBufEndError(const tchar *File, int Line);

enum DECODE_TOLERANCE
{
        DECODE_TOLERANCE_NONE,       
        DECODE_TOLERANCE_WHITESPACE, 
        DECODE_TOLERANCE_ALL,        
};


class Stream
{
public:
        virtual ~Stream() { }



        virtual void Write(const void *Data, size_t Size);
        virtual void Flush() { }

        template <typename T>
        void WriteEx(const T &x) { return Write(&x, sizeof(x)); }

        void WriteString1(const string &s);
        void WriteString1(const char *s);
        void WriteString1(const char *s, unsigned NumChars);
#ifdef WIN32
        void WriteString1(const wstring &s);
        void WriteString1(const wchar_t *s);
        void WriteString1(const wchar_t *s, unsigned NumChars);
#endif

        void WriteString2(const string &s);
        void WriteString2(const char *s);
        void WriteString2(const char *s, unsigned NumChars);
#ifdef WIN32
        void WriteString2(const wstring &s);
        void WriteString2(const wchar_t *s);
        void WriteString2(const wchar_t *s, unsigned NumChars);
#endif
        void WriteString4(const string &s);
        void WriteString4(const char *s);
        void WriteString4(const char *s, unsigned NumChars);
#ifdef WIN32
        void WriteString4(const wstring &s);
        void WriteString4(const wchar_t *s);
        void WriteString4(const wchar_t *s, unsigned NumChars);
#endif
        void WriteStringF(const string &s);
#ifdef WIN32
        void WriteStringF(const wstring &s);
#endif
        void WriteBool(bool b);




        virtual size_t Read(void *Data, size_t MaxLength);

        virtual void MustRead(void *Data, size_t Length);

        virtual bool End();

        virtual size_t Skip(size_t MaxLength);

        template <typename T>
        void ReadEx(T *x) { MustRead(x, sizeof(*x)); }
        void ReadString1(string *s);
        void ReadString2(string *s);
        void ReadString4(string *s);
        void ReadStringF(string *s, size_t NumChars);
        void ReadStringToEnd(string *s);
#ifdef WIN32
        void ReadString1(wstring *s);
        void ReadString2(wstring *s);
        void ReadString4(wstring *s);
        void ReadStringF(wstring *s, size_t NumChars);
        void ReadStringToEnd(wstring *s);
#endif
        void ReadBool(bool *b);

        void MustSkip(size_t Length);




        size_t CopyFrom(Stream *s, size_t Size);

        void MustCopyFrom(Stream *s, size_t Size);
        void CopyFromToEnd(Stream *s);
};

class SeekableStream : public Stream
{
public:
        // ======== Implementacja Stream ========
        virtual bool End();
        virtual size_t Skip(size_t MaxLength);


        virtual size_t GetSize();

        virtual int GetPos();

        virtual void SetPos(int pos);

        virtual void SetPosFromCurrent(int pos);

        virtual void SetPosFromEnd(int pos);

        virtual void Rewind();

        virtual void SetSize(size_t Size);

        virtual void Truncate();

        virtual void Clear();
};


class CharWriter
{
private:
        Stream *m_Stream;
        std::vector<char> m_Buf;
        uint m_BufIndex;

        // Wykonuje Flush danych z bufora do strumienia nie sprawdzając już, czy bufor nie jest pusty.
        // Oczywiście zeruje też BufIndex.
        void DoFlush() { m_Stream->Write(&m_Buf[0], m_BufIndex); m_BufIndex = 0; }

public:
        CharWriter(Stream *a_Stream) : m_Stream(a_Stream), m_BufIndex(0) { m_Buf.resize(BUFFER_SIZE); }
        ~CharWriter();

        void WriteChar(char Ch) { if (m_BufIndex == BUFFER_SIZE) DoFlush(); m_Buf[m_BufIndex++] = Ch; }
        void WriteString(const string &s);
        void WriteString(const char *s) { WriteString(s, strlen(s)); }
        void WriteString(const char *s, size_t NumChars) { WriteData(s, NumChars); }
        void WriteData(const void *Data, size_t Length);
        template <typename T> void WriteEx(const T &x) { string s; SthToStr<T>(&s, x); WriteString(s); }
        void Flush() { if (m_BufIndex > 0) DoFlush(); }
};

#ifdef WIN32

class WCharWriter
{
private:
        Stream *m_Stream;
        std::vector<wchar_t> m_Buf;
        uint m_BufIndex;

        // Wykonuje Flush danych z bufora do strumienia nie sprawdzając już, czy bufor nie jest pusty.
        // Oczywiście zeruje też BufIndex.
        void DoFlush() { m_Stream->Write(&m_Buf[0], m_BufIndex * sizeof(wchar_t)); m_BufIndex = 0; }

public:
        WCharWriter(Stream *a_Stream) : m_Stream(a_Stream), m_BufIndex(0) { m_Buf.resize(BUFFER_SIZE); }
        ~WCharWriter();

        void WriteChar(wchar_t Ch) { if (m_BufIndex == BUFFER_SIZE) DoFlush(); m_Buf[m_BufIndex++] = Ch; }
        void WriteString(const wstring &s);
        void WriteString(const wchar_t *s) { WriteString(s, wcslen(s)); }
        void WriteString(const wchar_t *s, size_t NumChars);
        void Flush() { if (m_BufIndex > 0) DoFlush(); }
};
#endif


class CharReader
{
private:
        Stream *m_Stream;
        std::vector<char> m_Buf;
        // Miejsce, do którego doczytałem z bufora
        uint m_BufBeg;
        // Miejsce, do którego bufor jest wypełniony danymi
        uint m_BufEnd;

        // Wczytuje nową porcję danych do strumienia
        // Wywoływać tylko kiedy bufor się skończył, tzn. m_BufBeg == m_BufEnd.
        // Jeśli skończył się strumień i nic nie udało się wczytać, zwraca false.
        // Jeśli nie, zapewnia że w buforze będzie co najmniej jeden znak.
        bool EnsureNewChars();

public:
        CharReader(Stream *a_Stream) : m_Stream(a_Stream), m_BufBeg(0), m_BufEnd(0) { m_Buf.resize(BUFFER_SIZE); }

        bool End() {
                return (m_BufBeg == m_BufEnd) && m_Stream->End(); // Nic nie zostało w buforze i nic nie zostało w strumieniu.
        }

        bool ReadChar(char *Out) { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) return false; } *Out = m_Buf[m_BufBeg++]; return true; }

        char MustReadChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) _ThrowBufEndError(__TFILE__, __LINE__); } return m_Buf[m_BufBeg++]; }

        bool PeekChar(char *Out) { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) return false; } *Out = m_Buf[m_BufBeg]; return true; }

        char MustPeekChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) _ThrowBufEndError(__TFILE__, __LINE__); } return m_Buf[m_BufBeg]; }

        size_t ReadString(string *Out, size_t MaxLength);

        void MustReadString(string *Out, size_t Length);

        size_t ReadString(char *Out, size_t MaxLength);

        void MustReadString(char *Out, size_t Length);

        size_t ReadData(void *Out, size_t MaxLength);

        void MustReadData(void *Out, size_t Length);

        bool SkipChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) return false; } m_BufBeg++; return true; }

        void MustSkipChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) _ThrowBufEndError(__TFILE__, __LINE__); } m_BufBeg++; }

        size_t Skip(size_t MaxLength);

        void MustSkip(size_t Length);

        bool ReadLine(string *Out);

        void MustReadLine(string *Out);
};

#ifdef WIN32

class WCharReader
{
private:
        Stream *m_Stream;
        std::vector<wchar_t> m_Buf;
        // Miejsce, do którego doczytałem z bufora
        uint m_BufBeg;
        // Miejsce, do którego bufor jest wypełniony danymi
        uint m_BufEnd;

        // Wczytuje nową porcję danych do strumienia
        // Wywoływać tylko kiedy bufor się skończył, tzn. m_BufBeg == m_BufEnd.
        // Jeśli skończył się strumień i nic nie udało się wczytać, zwraca false.
        // Jeśli nie, zapewnia że w buforze będzie co najmniej jeden znak.
        bool EnsureNewChars();

public:
        WCharReader(Stream *a_Stream) : m_Stream(a_Stream), m_BufBeg(0), m_BufEnd(0) { m_Buf.resize(BUFFER_SIZE); }

        bool End() {
                return (m_BufBeg == m_BufEnd) && m_Stream->End(); // Nic nie zostało w buforze i nic nie zostało w strumieniu.
        }

        bool ReadChar(wchar_t *Out) { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) return false; } *Out = m_Buf[m_BufBeg++]; return true; }

        wchar_t MustReadChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) _ThrowBufEndError(__TFILE__, __LINE__); } return m_Buf[m_BufBeg++]; }

        bool PeekChar(wchar_t *Out) { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) return false; } *Out = m_Buf[m_BufBeg]; return true; }

        wchar_t MustPeekChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) _ThrowBufEndError(__TFILE__, __LINE__); } return m_Buf[m_BufBeg]; }

        size_t ReadString(wstring *Out, size_t MaxLength);

        void MustReadString(wstring *Out, size_t Length);

        size_t ReadString(wchar_t *Out, size_t MaxLength);

        void MustReadString(wchar_t *Out, size_t Length);

        bool SkipChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) return false; } m_BufBeg++; return true; }

        void MustSkipChar() { if (m_BufBeg == m_BufEnd) { if (!EnsureNewChars()) _ThrowBufEndError(__TFILE__, __LINE__); } m_BufBeg++; }

        size_t Skip(size_t MaxLength);

        void MustSkip(size_t Length);

        bool ReadLine(wstring *Out);

        void MustReadLine(wstring *Out);
};
#endif

#ifdef _UNICODE
        #define TCharWriter WCharWriter
        #define TCharReader WCharReader
#else
        #define TCharWriter CharWriter
        #define TCharReader CharReader
#endif


class MemoryStream : public SeekableStream
{
private:
        char *m_Data;
        size_t m_Size;
        int m_Pos;
        bool m_InternalAlloc;

public:
        MemoryStream(size_t Size, void *Data = 0);
        virtual ~MemoryStream();

        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Data, size_t Size);
        virtual void MustRead(void *Data, size_t Size);

        virtual size_t GetSize();
        virtual int GetPos();
        virtual void SetPos(int pos);
        virtual void Rewind();

        char *Data() { return m_Data; }
};


class VectorStream : public SeekableStream
{
private:
        char *m_Data;
        size_t m_Size;
        size_t m_Capacity;
        int m_Pos;

        // Zmienia capacity, a tym samym przealokowuje pamięć.
        // O niczym sama nie decyduje ani niczego nie sprawdza.
        void Reserve(size_t NewCapacity);

public:
        VectorStream();
        virtual ~VectorStream();

        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Data, size_t Size);
        virtual void MustRead(void *Data, size_t Size);
        virtual size_t GetSize() { return m_Size; }
        virtual int GetPos() { return m_Pos; }
        virtual void SetPos(int pos) { m_Pos = pos; }
        virtual void Rewind() { m_Pos = 0; }
        virtual void SetSize(size_t Size);

        size_t GetCapacity() { return m_Capacity; }
        void SetCapacity(size_t Capacity);
        char *Data() { return m_Data; }
};


class StringStream : public SeekableStream
{
private:
        std::string *m_Data;
        int m_Pos;
        bool m_InternalAlloc;

public:
        StringStream(string *Data = 0);
        virtual ~StringStream();

        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Data, size_t Size);
        virtual void MustRead(void *Data, size_t Size);
        virtual size_t GetSize() { return m_Data->length(); }
        virtual int GetPos() { return m_Pos; }
        virtual void SetPos(int pos) { m_Pos = pos; }
        virtual void Rewind() { m_Pos = 0; }
        virtual void SetSize(size_t Size) { m_Data->resize(Size); }
        virtual void Clear() { m_Data->clear(); }

        size_t GetCapacity() { return m_Data->capacity(); }
        void SetCapacity(size_t Capacity) { m_Data->reserve(Capacity); }
        string *Data() { return m_Data; }
};

class OverlayStream : public Stream
{
private:
        Stream *m_Stream;

public:
        OverlayStream(Stream *a_Stream) : m_Stream(a_Stream) { }

        Stream * GetStream() { return m_Stream; }

        // ======== Implementacja Stream ========
        virtual bool End() { return m_Stream->End(); }
        virtual void Flush() { m_Stream->Flush(); }
};

class CounterOverlayStream : public OverlayStream
{
private:
        uint4 m_WriteCounter;
        uint4 m_ReadCounter;

public:
        CounterOverlayStream(Stream *a_Stream);

        // ====== Implementacja Stream ======
        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Data, size_t Size);
        virtual void MustRead(void *Data, size_t Size);
        virtual void Flush();

        uint4 GetWriteCounter() { return m_WriteCounter; }
        uint4 GetReadCounter() { return m_ReadCounter; }
        void ResetWriteCounter() { m_WriteCounter = 0; }
        void ResetReadCounter() { m_ReadCounter = 0; }
};


class LimitOverlayStream : public OverlayStream
{
private:
        // Przechowują aktualny limit, jaki pozostał.
        // Są zmniejszane przez funkcje odczytujące i zapisujące.
        uint4 m_WriteLimit;
        uint4 m_ReadLimit;

public:
        LimitOverlayStream(Stream *a_Stream, uint4 WriteLimit, uint4 ReadLimit);

        // ====== Implementacja Stream ======
        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Data, size_t Size);
        virtual void Flush();

        void SetWriteLimit(uint4 WriteLimit);
        void SetReadLimit(uint4 ReadLimit);
};

class MultiWriterStream : public Stream
{
private:
        std::vector<Stream*> m_Streams;

public:
        MultiWriterStream() { }
        MultiWriterStream(Stream *a_Streams[], uint StreamCount);

        void AddStream(Stream *a_Stream) { m_Streams.push_back(a_Stream); }
        void RemoveStream(Stream *a_Stream);
        void ClearStreams() { m_Streams.clear(); }
        size_t GetStreamCount() { return m_Streams.size(); }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);
        virtual void Flush();
};


class Hash_Calc : public Stream
{
private:
        uint4 m_Hash;

public:
        Hash_Calc() : m_Hash(0) { }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);

        uint4 Finish();
        void Reset() { m_Hash = 0; }

        // ======== Statyczne ========
        static uint4 Calc(const void *Buf, uint4 BufLen);
        static uint4 Calc(const string &s);
#ifdef WIN32
        static uint4 Calc(const wstring &s);
#endif
};


class CRC32_Calc : public Stream
{
private:
        uint m_CRC;

public:
        CRC32_Calc() { m_CRC = 0xFFFFFFFF; }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);

        uint GetResult() { return ~m_CRC; }
        void Reset() { m_CRC = 0xFFFFFFFF; }

        // ======== Statyczne ========
        static uint Calc(const void *Data, size_t DataLength);
};


struct MD5_SUM
{
        uint1 Data[16];

        uint1 & operator [] (size_t i) { return Data[i]; }
        uint1 operator [] (size_t i) const { return Data[i]; }

        bool operator == (const MD5_SUM &s) const
        {
                return
                        Data[ 0] == s.Data[ 0] && Data[ 1] == s.Data[ 1] && Data[ 2] == s.Data[ 2] && Data[ 3] == s.Data[ 3] &&
                        Data[ 4] == s.Data[ 4] && Data[ 5] == s.Data[ 5] && Data[ 6] == s.Data[ 6] && Data[ 7] == s.Data[ 7] &&
                        Data[ 8] == s.Data[ 8] && Data[ 9] == s.Data[ 9] && Data[10] == s.Data[10] && Data[11] == s.Data[11] &&
                        Data[12] == s.Data[12] && Data[13] == s.Data[13] && Data[14] == s.Data[14] && Data[15] == s.Data[15];
        }
        bool operator != (const MD5_SUM &s) const
        {
                return
                        Data[ 0] != s.Data[ 0] || Data[ 1] != s.Data[ 1] || Data[ 2] != s.Data[ 2] || Data[ 3] != s.Data[ 3] ||
                        Data[ 4] != s.Data[ 4] || Data[ 5] != s.Data[ 5] || Data[ 6] != s.Data[ 6] || Data[ 7] != s.Data[ 7] ||
                        Data[ 8] != s.Data[ 8] || Data[ 9] != s.Data[ 9] || Data[10] != s.Data[10] || Data[11] != s.Data[11] ||
                        Data[12] != s.Data[12] || Data[13] != s.Data[13] || Data[14] != s.Data[14] || Data[15] != s.Data[15];
        }
        bool operator < (const MD5_SUM &s) const;
        bool operator > (const MD5_SUM &s) const;
        bool operator <= (const MD5_SUM &s) const;
        bool operator >= (const MD5_SUM &s) const;
};

void MD5ToStr(tstring *Out, const MD5_SUM MD5);
bool StrToMD5(MD5_SUM *Out, const tstring &s);


class MD5_Calc : public Stream
{
private:
        uint4 total[2];
        uint4 state[4];
        uint1 buffer[64];

        void Process(uint1 data[64]);

public:
        MD5_Calc();

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);

        void Finish(MD5_SUM *Out);
        void Reset();

        // ======== Statyczne ========
        static void Calc(MD5_SUM *Out, const void *Buf, uint4 BufLen);
};


class XorCoder : public OverlayStream
{
private:
        std::vector<char> m_Buf;
        std::vector<char> m_Key;
        uint m_EncodeKeyIndex;
        uint m_DecodeKeyIndex;

public:
        XorCoder(Stream *a_Stream, char KeyByte);
        XorCoder(Stream *a_Stream, const void *KeyData, size_t KeyLength);
        XorCoder(Stream *a_Stream, const string &Key);

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Data, size_t Size);

        void Reset() { m_EncodeKeyIndex = m_DecodeKeyIndex = 0; }

        // ======== Statyczne ========
        static void Code(void *Out, const void *Data, size_t DataLength, const void *Key, size_t KeyLength);
        static void Code(string *Out, const string &Data, const string &Key);
#ifdef WIN32
        static void Code(wstring *Out, const wstring &Data, const wstring &Key);
#endif
};

class BinEncoder : public OverlayStream
{
private:
        CharWriter m_CharWriter;

public:
        BinEncoder(Stream *a_Stream) : OverlayStream(a_Stream), m_CharWriter(a_Stream) { }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);
        virtual void Flush() { m_CharWriter.Flush(); OverlayStream::Flush(); }

        // ======== Statyczne ========
        /*** \param[out] Out Bufor wyjściowy Out musi mieć zaalokowane przynajmniej DataLength * 8 bajtów. */
        static void Encode(char *Out, const void *Data, size_t DataLength);

        static void Encode(string *Out, const void *Data, size_t DataLength);
};

class BinDecoder : public OverlayStream
{
private:
        CharReader m_CharReader;
        DECODE_TOLERANCE m_Tolerance;

public:
        BinDecoder(Stream *a_Stream, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);

        DECODE_TOLERANCE GetTolerance() { return m_Tolerance; }

        // ======== Implementacja Stream ========
        virtual size_t Read(void *Out, size_t Size);
        virtual bool End() { return m_CharReader.End(); }

        // ======== Statyczne ========

        static bool DecodeLength(uint *OutLength, const string &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static bool DecodeLength(uint *OutLength, const char *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);

        static size_t Decode(void *OutData, const string &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static size_t Decode(void *OutData, const char *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
};

class HexEncoder : public OverlayStream
{
private:
        CharWriter m_CharWriter;
        bool m_UpperCase;

public:
        HexEncoder(Stream *a_Stream, bool UpperCase = true) : OverlayStream(a_Stream), m_CharWriter(a_Stream), m_UpperCase(UpperCase) { }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);
        virtual void Flush() { m_CharWriter.Flush(); OverlayStream::Flush(); }

        // ======== Statyczne ========

        static void Encode(char *Out, const void *Data, size_t DataLength, bool UpperCase = true);

        static void Encode(string *Out, const void *Data, size_t DataLength, bool UpperCase = true);
#ifdef WIN32
        static void Encode(wchar_t *Out, const void *Data, size_t DataLength, bool UpperCase = true);
        static void Encode(wstring *Out, const void *Data, size_t DataLength, bool UpperCase = true);
#endif
};


class HexDecoder : public OverlayStream
{
private:
        CharReader m_CharReader;
        DECODE_TOLERANCE m_Tolerance;

public:
        HexDecoder(Stream *a_Stream, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);

        DECODE_TOLERANCE GetTolerance() { return m_Tolerance; }

        // ======== Implementacja Stream ========
        virtual size_t Read(void *Out, size_t Size);
        virtual bool End() { return m_CharReader.End(); }

        // ======== Statyczne ========

        static bool DecodeLength(uint *OutLength, const string &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static bool DecodeLength(uint *OutLength, const char *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);

        static size_t Decode(void *OutData, const string &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static size_t Decode(void *OutData, const char *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
#ifdef WIN32
        static size_t Decode(void *OutData, const wstring &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static size_t Decode(void *OutData, const wchar_t *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
#endif
};


class Base64Encoder : public OverlayStream
{
private:
        CharWriter m_CharWriter;
        bool m_Finished; // Czy dane zakończone
        uint1 m_Buf[2];
        uint m_BufIndex;

        void DoFinish();

public:
        Base64Encoder(Stream *a_Stream) : OverlayStream(a_Stream), m_CharWriter(a_Stream), m_Finished(false), m_BufIndex(0) { }
        ~Base64Encoder();

        void Finish() { if (!m_Finished) { DoFinish(); m_Finished = true; } }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);
        virtual void Flush() { m_CharWriter.Flush(); OverlayStream::Flush(); }

        // ======== Statyczne ========
        static size_t EncodeLength(size_t DataLength);

        static size_t Encode(char *Out, const void *Data, size_t DataLength);

        static size_t Encode(string *Out, const void *Data, size_t DataLength);
};

/*
- Po napotkaniu końcówki zawierającej znaki '=' funkcje nie parsują już dalej,
  ale to tylko optymalizacja i nie należy na tym polegać.
- Sposób działania strumienia - na raz wczytywane są po 4 znaki i zamieniane na
  maksymalnie 3 bajty.
*/
class Base64Decoder : public OverlayStream
{
private:
        CharReader m_CharReader;
        DECODE_TOLERANCE m_Tolerance;
        // Bajty są w kolejności: [2][1][0]. Jeśli jest mniej, to [1][0][-] albo [0][-][-].
        uint1 m_Buf[3];
        // Liczba zdekodowanych bajtów w buforze
        uint m_BufLength;
        // True, jeśli sparsowano końcówkę z '='
        bool m_Finished;

        // Czyta 4 znaki ze strumienia podłączonego (0 albo 4, inaczej błąd) i wypełnia m_Buf maksymalnie 3 zdekodowanymi bajtami.
        // Ustawia m_BufLength i jeśli trzeba, to m_Finished.
        bool ReadNextBuf();

        bool GetNextByte(uint1 *OutByte) { if (m_BufLength == 0) { if (!ReadNextBuf()) return false; } *OutByte = m_Buf[--m_BufLength]; return true; }

public:
        Base64Decoder(Stream *a_Stream, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);

        DECODE_TOLERANCE GetTolerance() { return m_Tolerance; }

        // ======== Implementacja Stream ========
        virtual size_t Read(void *Out, size_t Size);
        virtual bool End();

        // ======== Statyczne ========

        static bool DecodeLength(uint *OutLength, const string &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static bool DecodeLength(uint *OutLength, const char *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);

        static size_t Decode(void *OutData, const string &s, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
        static size_t Decode(void *OutData, const char *s, uint s_Length, DECODE_TOLERANCE Tolerance = DECODE_TOLERANCE_NONE);
};

/*
Działa szybko (na tyle na ile szybko może działać strumień, ze
swoimi metodami wirtualnymi itd.), ale ma z góry ograniczoną pojemność. W
przypadku przepełnienia przy zapisie rzuca wyjątek.
*/
class RingBuffer : public Stream
{
public:
        RingBuffer(uint Capacity);
        virtual ~RingBuffer();

        uint GetSize() { return m_Size; }
        uint GetCapacity() { return m_Capacity; }
        bool IsEmpty() { return GetSize() == 0; }
        bool IsFull() { return GetSize() == GetCapacity(); }

        // ======== Implementacja Stream ========
        virtual void Write(const void *Data, size_t Size);
        virtual size_t Read(void *Out, size_t MaxLength);
        virtual void MustRead(void *Out, size_t Length);
        virtual bool End();
        virtual size_t Skip(size_t MaxLength);

private:
        uint m_Capacity;
        uint m_Size;
        std::vector<char> m_Buf;
        uint m_BegIndex;
        uint m_EndIndex;
};



inline size_t Copy(Stream *Dst, Stream *Src, size_t MaxLength) { return Dst->CopyFrom(Src, MaxLength); }

inline void MustCopy(Stream *Dst, Stream *Src, size_t Length) { return Dst->MustCopyFrom(Src, Length); }
inline void CopyToEnd(Stream *Dst, Stream *Src) { Dst->CopyFromToEnd(Src); }

// code_stream

} // namespace common


template <>
struct SthToStr_obj<common::MD5_SUM>
{
        void operator () (tstring *Str, const common::MD5_SUM &Sth)
        {
                common::MD5ToStr(Str, Sth);
        }
        static inline bool IsSupported() { return true; }
};

template <>
struct StrToSth_obj<common::MD5_SUM>
{
        bool operator () (common::MD5_SUM *Sth, const tstring &Str)
        {
                return common::StrToMD5(Sth, Str);
        }
        static inline bool IsSupported() { return true; }
};

// code_sthtostr

#endif

---