Stream.hpp

Go to the documentation of this file.

#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);
  size_t 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 NullStream : public SeekableStream
{
public:
  virtual void Write(const void *Data, size_t Size) { }
  virtual size_t Read(void *Data, size_t MaxLength) { return 0; }
  virtual bool End() { return true; }
  virtual size_t Skip(size_t MaxLength) { return 0; }
  virtual size_t GetSize() { return 0; }
  virtual int GetPos() { return 0; }
  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 BufferingStream : public OverlayStream
{
public:
  BufferingStream(Stream *stream, uint readBufSize, uint writeBufSize);
  ~BufferingStream();

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

  void WriteChar(char ch) { if (m_WriteBufIndex == m_WriteBufSize) DoFlush(); m_WriteBuf[m_WriteBufIndex++] = ch; }

private:
  uint m_ReadBufSize, m_WriteBufSize;
  std::vector<char> m_ReadBuf, m_WriteBuf;
  uint m_ReadBufBeg, m_ReadBufEnd, m_WriteBufIndex;

  void DoFlush();
  // Wczytuje nową porcję danych do bufora
  // Wywoływać tylko kiedy bufor się skończył, tzn. m_ReadBufBeg == m_ReadBufEnd.
  // 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();
};

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 size_t CopyToEnd(Stream *Dst, Stream *Src) { return 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

---