Commit: 78e54ff3437b86dd432f10cda34a481e95961d22 - ziplib (git)

Commit MetaInfo

• Revision: 78e54ff3437b86dd432f10cda34a481e95961d22 (tree)
• Zeit: 2014-05-19 05:10:30
• Autor: wbenny <w.benny@outl...>
• Commiter: wbenny

Log Message

* Remove dependency on char_type in non-stream classes and use uint8_t instead.
* Move serialize/deserialize functions into utils::stream namespace.

Ändern Zusammenfassung

• modified: Source/Sample/Main.cpp
• modified: Source/Sample/Sample.vcxproj
• modified: Source/ZipLib/ZipArchive.cpp
• modified: Source/ZipLib/ZipLib.vcxproj
• modified: Source/ZipLib/ZipLib.vcxproj.filters
• modified: Source/ZipLib/compression/bzip2/bzip2_decoder.h
• modified: Source/ZipLib/compression/bzip2/bzip2_encoder.h
• modified: Source/ZipLib/compression/compression_interface.h
• modified: Source/ZipLib/compression/deflate/deflate_decoder.h
• modified: Source/ZipLib/compression/deflate/deflate_encoder.h
• modified: Source/ZipLib/compression/lzma/detail/lzma_in_stream.h
• modified: Source/ZipLib/compression/lzma/detail/lzma_out_stream.h
• modified: Source/ZipLib/compression/lzma/lzma_decoder.h
• modified: Source/ZipLib/compression/lzma/lzma_encoder.h
• modified: Source/ZipLib/compression/store/store_decoder.h
• modified: Source/ZipLib/compression/store/store_encoder.h
• modified: Source/ZipLib/detail/EndOfCentralDirectoryBlock.cpp
• modified: Source/ZipLib/detail/ZipCentralDirectoryFileHeader.cpp
• modified: Source/ZipLib/detail/ZipGenericExtraField.cpp
• modified: Source/ZipLib/detail/ZipLocalFileHeader.cpp
• modified: Source/ZipLib/encryption/aes/aes_decoder.h
• modified: Source/ZipLib/encryption/aes/aes_encoder.h
• modified: Source/ZipLib/encryption/aes/detail/aes_types.h
• modified: Source/ZipLib/encryption/encryption_interface.h
• modified: Source/ZipLib/encryption/zipcrypto/zipcrypto_decoder.h
• modified: Source/ZipLib/encryption/zipcrypto/zipcrypto_encoder.h
• modified: Source/ZipLib/extlibs/aes/aes.vcxproj
• modified: Source/ZipLib/extlibs/bzip2/bzip2.vcxproj
• modified: Source/ZipLib/extlibs/lzma/lzma.vcxproj
• modified: Source/ZipLib/extlibs/zlib/zlib.vcxproj
• modified: Source/ZipLib/methods/encryption/detail/AesExtraField.h
• modified: Source/ZipLib/streams/streambuffs/compression_decoder_streambuf.h
• modified: Source/ZipLib/streams/streambuffs/compression_encoder_streambuf.h
• modified: Source/ZipLib/streams/streambuffs/encryption_decoder_streambuf.h
• modified: Source/ZipLib/streams/streambuffs/encryption_encoder_streambuf.h
• add: Source/ZipLib/utils/stream/copy.h
• modified: Source/ZipLib/utils/stream_utils.h
• delete: Source/ZipLib/{streams => utils/stream}/serialization.h

Diff

--- a/Source/Sample/Main.cpp
+++ b/Source/Sample/Main.cpp
@@ -114,7 +114,7 @@ TEST_METHOD(Sample_ZipArchive_Stream_Deferred_Comment)
   //// this method is only useful for password protected files
   //entry->UseDataDescriptor();
 
-  StoreMethod::Ptr ctx = StoreMethod::Create();
+  LzmaMethod::Ptr ctx = LzmaMethod::Create();
   AesCryptoMethod::Ptr encryptionCtx = AesCryptoMethod::Create();
   encryptionCtx->SetPassword("gogo");
   ctx->SetEncryptionMethod(encryptionCtx);

--- a/Source/Sample/Sample.vcxproj
+++ b/Source/Sample/Sample.vcxproj
@@ -94,7 +94,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4250;4996</DisableSpecificWarnings>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -110,6 +110,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4250;4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

--- a/Source/ZipLib/ZipArchive.cpp
+++ b/Source/ZipLib/ZipArchive.cpp
@@ -1,5 +1,5 @@
 #include "ZipArchive.h"
-#include "streams/serialization.h"
+#include "utils/stream/serialization.h"
 
 #include <algorithm>
 #include <cassert>
@@ -197,7 +197,7 @@ bool ZipArchive::SeekToSignature(uint32_t signature, SeekDirection direction)
 
   while (!_zipStream->eof() && !_zipStream->fail())
   {
-    deserialize(*_zipStream, buffer);
+    utils::stream::deserialize(*_zipStream, buffer);
 
     if (buffer == signature)
     {

--- a/Source/ZipLib/ZipLib.vcxproj
+++ b/Source/ZipLib/ZipLib.vcxproj
@@ -79,7 +79,6 @@
     <ClInclude Include="streams\encryption_encoder_stream.h" />
     <ClInclude Include="streams\memstream.h" />
     <ClInclude Include="streams\nullstream.h" />
-    <ClInclude Include="streams\serialization.h" />
     <ClInclude Include="streams\streambuffs\audit_streambuf.h" />
     <ClInclude Include="streams\streambuffs\compression_decoder_streambuf.h" />
     <ClInclude Include="streams\streambuffs\compression_encoder_streambuf.h" />
@@ -93,6 +92,8 @@
     <ClInclude Include="streams\substream.h" />
     <ClInclude Include="streams\teestream.h" />
     <ClInclude Include="utils\enum_utils.h" />
+    <ClInclude Include="utils\stream\copy.h" />
+    <ClInclude Include="utils\stream\serialization.h" />
     <ClInclude Include="utils\stream_utils.h" />
     <ClInclude Include="utils\time_utils.h" />
     <ClInclude Include="ZipArchive.h" />
@@ -197,6 +198,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -211,6 +213,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

--- a/Source/ZipLib/ZipLib.vcxproj.filters
+++ b/Source/ZipLib/ZipLib.vcxproj.filters
@@ -85,6 +85,9 @@
     <Filter Include="Header Files\methods\encryption\detail">
       <UniqueIdentifier>{fdd8531d-8da9-439a-bde5-24b55515a5c9}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\utils\stream">
+      <UniqueIdentifier>{7aa687c2-d8de-4cdb-a3fb-20076486838b}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ZipFile.h">
@@ -135,9 +138,6 @@
     <ClInclude Include="streams\memstream.h">
       <Filter>Header Files\streams</Filter>
     </ClInclude>
-    <ClInclude Include="streams\serialization.h">
-      <Filter>Header Files\streams</Filter>
-    </ClInclude>
     <ClInclude Include="streams\substream.h">
       <Filter>Header Files\streams</Filter>
     </ClInclude>
@@ -324,6 +324,12 @@
     <ClInclude Include="compression\bzip2\bzip2_properties.h">
       <Filter>Header Files\compression\bzip2</Filter>
     </ClInclude>
+    <ClInclude Include="utils\stream\copy.h">
+      <Filter>Header Files\utils\stream</Filter>
+    </ClInclude>
+    <ClInclude Include="utils\stream\serialization.h">
+      <Filter>Header Files\utils\stream</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="ZipFile.cpp">

--- a/Source/ZipLib/compression/bzip2/bzip2_decoder.h
+++ b/Source/ZipLib/compression/bzip2/bzip2_decoder.h
@@ -1,8 +1,7 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "bzip2_properties.h"
-
+#include "../compression_interface.h"
+#include "../../utils/stream/serialization.h"
 #include "../../extlibs/bzip2/bzlib.h"
 
 #include <cstdint>
@@ -45,17 +44,17 @@ class bzip2_decoder
       _bufferCapacity = bzip2Props.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
-      _outputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer        = new uint8_t[_bufferCapacity];
+      _outputBuffer       = new uint8_t[_bufferCapacity];
 
       // init bzip2
-      _bzstream.bzalloc = nullptr;
-      _bzstream.bzfree = nullptr;
-      _bzstream.opaque = nullptr;
+      _bzstream.bzalloc   = nullptr;
+      _bzstream.bzfree    = nullptr;
+      _bzstream.opaque    = nullptr;
 
-      _bzstream.next_in = nullptr;
-      _bzstream.next_out = nullptr;
-      _bzstream.avail_in = 0;
+      _bzstream.next_in   = nullptr;
+      _bzstream.next_out  = nullptr;
+      _bzstream.avail_in  = 0;
       _bzstream.avail_out = (unsigned int)-1; // force first load of data
 
       // no verbosity & do not use small memory model
@@ -67,12 +66,12 @@ class bzip2_decoder
       return (_inputBuffer != nullptr && _outputBuffer != nullptr);
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _outputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _outputBuffer + _outputBufferSize;
     }
@@ -139,7 +138,7 @@ class bzip2_decoder
     void read_next()
     {
       // read next bytes from input stream
-      _stream->read(_inputBuffer, _bufferCapacity);
+      utils::stream::deserialize(*_stream, _inputBuffer, _bufferCapacity);
 
       // set the size of buffer
       _inputBufferSize = static_cast<size_t>(_stream->gcount());
@@ -162,6 +161,6 @@ class bzip2_decoder
     size_t     _bufferCapacity    = 0;
     size_t     _inputBufferSize   = 0;        // how many bytes are read in the input buffer
     size_t     _outputBufferSize  = 0;        // how many bytes are written in the output buffer
-    char_type* _inputBuffer       = nullptr;  // pointer to the start of the input buffer
-    char_type* _outputBuffer      = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _inputBuffer       = nullptr;  // pointer to the start of the input buffer
+    uint8_t*   _outputBuffer      = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/compression/bzip2/bzip2_encoder.h
+++ b/Source/ZipLib/compression/bzip2/bzip2_encoder.h
@@ -1,8 +1,7 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "bzip2_properties.h"
-
+#include "../compression_interface.h"
+#include "../../utils/stream/serialization.h"
 #include "../../extlibs/bzip2/bzlib.h"
 
 #include <cstdint>
@@ -41,17 +40,17 @@ class bzip2_encoder
       _bufferCapacity = bz2Props.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
-      _outputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer        = new uint8_t[_bufferCapacity];
+      _outputBuffer       = new uint8_t[_bufferCapacity];
 
       // init bzip2
-      _bzstream.bzalloc = nullptr;
-      _bzstream.bzfree = nullptr;
-      _bzstream.opaque = nullptr;
+      _bzstream.bzalloc   = nullptr;
+      _bzstream.bzfree    = nullptr;
+      _bzstream.opaque    = nullptr;
 
-      _bzstream.next_in = nullptr;
-      _bzstream.next_out = nullptr;
-      _bzstream.avail_in = 0;
+      _bzstream.next_in   = nullptr;
+      _bzstream.next_out  = nullptr;
+      _bzstream.avail_in  = 0;
       _bzstream.avail_out = 0;
 
       _lastError = BZ2_bzCompressInit(&_bzstream, bz2Props.BlockSize, 0, bz2Props.WorkFactor);
@@ -62,12 +61,12 @@ class bzip2_encoder
       return _stream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
@@ -93,7 +92,7 @@ class bzip2_encoder
 
         if (have > 0)
         {
-          _stream->write(_outputBuffer, have);
+          utils::stream::serialize(*_stream, _outputBuffer, have);
         }
       } while (_bzstream.avail_out == 0);
     }
@@ -121,6 +120,6 @@ class bzip2_encoder
     std::ostream* _stream       = nullptr;
 
     size_t     _bufferCapacity  = 0;
-    char_type* _inputBuffer     = nullptr;  // pointer to the start of the input buffer
-    char_type* _outputBuffer    = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _inputBuffer     = nullptr;  // pointer to the start of the input buffer
+    uint8_t*   _outputBuffer    = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/compression/compression_interface.h
+++ b/Source/ZipLib/compression/compression_interface.h
@@ -19,14 +19,12 @@ struct compression_properties_interface
 class compression_interface
 {
   public:
-    typedef char char_type;
-
     virtual ~compression_interface() { }
 
     virtual bool is_init() const = 0;
 
-    virtual char_type* get_buffer_begin() = 0;
-    virtual char_type* get_buffer_end() = 0;
+    virtual uint8_t* get_buffer_begin() = 0;
+    virtual uint8_t* get_buffer_end() = 0;
 };
 
 class compression_encoder_interface

--- a/Source/ZipLib/compression/deflate/deflate_decoder.h
+++ b/Source/ZipLib/compression/deflate/deflate_decoder.h
@@ -1,9 +1,8 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "deflate_properties.h"
-
-#include "../../extlibs/zlib/zlib.h"
+#include "../compression_interface.h"
+#include "../../utils/stream/serialization.h"
+#include "../../extlibs/zlib/zlib.h"  
 
 #include <cstdint>
 
@@ -45,18 +44,18 @@ class deflate_decoder
       _bufferCapacity = deflateProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
-      _outputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer        = new uint8_t[_bufferCapacity];
+      _outputBuffer       = new uint8_t[_bufferCapacity];
 
       // init deflate
-      _zstream.zalloc = nullptr;
-      _zstream.zfree = nullptr;
-      _zstream.opaque = nullptr;
+      _zstream.zalloc     = nullptr;
+      _zstream.zfree      = nullptr;
+      _zstream.opaque     = nullptr;
 
-      _zstream.next_in = nullptr;
-      _zstream.next_out = nullptr;
-      _zstream.avail_in = 0;
-      _zstream.avail_out = uInt(-1); // force first load of data
+      _zstream.next_in    = nullptr;
+      _zstream.next_out   = nullptr;
+      _zstream.avail_in   = 0;
+      _zstream.avail_out  = uInt(-1); // force first load of data
 
       inflateInit2(&_zstream, -MAX_WBITS);
     }
@@ -66,12 +65,12 @@ class deflate_decoder
       return (_inputBuffer != nullptr && _outputBuffer != nullptr);
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _outputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _outputBuffer + _outputBufferSize;
     }
@@ -138,7 +137,7 @@ class deflate_decoder
     void read_next()
     {
       // read next bytes from input stream
-      _stream->read(_inputBuffer, _bufferCapacity);
+      utils::stream::deserialize(*_stream, _inputBuffer, _bufferCapacity);
 
       // set the size of buffer
       _inputBufferSize = static_cast<size_t>(_stream->gcount());
@@ -161,6 +160,6 @@ class deflate_decoder
     size_t     _bufferCapacity    = 0;
     size_t     _inputBufferSize   = 0;        // how many bytes are read in the input buffer
     size_t     _outputBufferSize  = 0;        // how many bytes are written in the output buffer
-    char_type* _inputBuffer       = nullptr;  // pointer to the start of the input buffer
-    char_type* _outputBuffer      = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _inputBuffer       = nullptr;  // pointer to the start of the input buffer
+    uint8_t*   _outputBuffer      = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/compression/deflate/deflate_encoder.h
+++ b/Source/ZipLib/compression/deflate/deflate_encoder.h
@@ -1,8 +1,7 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "deflate_properties.h"
-
+#include "../compression_interface.h"
+#include "../../utils/stream/serialization.h"
 #include "../../extlibs/zlib/zlib.h"
 
 #include <cstdint>
@@ -41,18 +40,18 @@ class deflate_encoder
       _bufferCapacity = deflateProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
-      _outputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer        = new uint8_t[_bufferCapacity];
+      _outputBuffer       = new uint8_t[_bufferCapacity];
 
       // init deflate
-      _zstream.zalloc = nullptr;
-      _zstream.zfree = nullptr;
-      _zstream.opaque = nullptr;
+      _zstream.zalloc     = nullptr;
+      _zstream.zfree      = nullptr;
+      _zstream.opaque     = nullptr;
 
-      _zstream.next_in = nullptr;
-      _zstream.next_out = nullptr;
-      _zstream.avail_in = 0;
-      _zstream.avail_out = 0;
+      _zstream.next_in    = nullptr;
+      _zstream.next_out   = nullptr;
+      _zstream.avail_in   = 0;
+      _zstream.avail_out  = 0;
 
       deflateInit2(&_zstream, deflateProps.CompressionLevel, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
     }
@@ -62,12 +61,12 @@ class deflate_encoder
       return _stream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
@@ -93,7 +92,7 @@ class deflate_encoder
 
         if (have > 0)
         {
-          _stream->write(_outputBuffer, have);
+          utils::stream::serialize(*_stream, _outputBuffer, have);
         }
       } while (_zstream.avail_out == 0);
     }
@@ -121,6 +120,6 @@ class deflate_encoder
     std::ostream* _stream       = nullptr;
 
     size_t     _bufferCapacity  = 0;
-    char_type* _inputBuffer     = nullptr;  // pointer to the start of the input buffer
-    char_type* _outputBuffer    = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _inputBuffer     = nullptr;  // pointer to the start of the input buffer
+    uint8_t*   _outputBuffer    = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/compression/lzma/detail/lzma_in_stream.h
+++ b/Source/ZipLib/compression/lzma/detail/lzma_in_stream.h
@@ -15,7 +15,6 @@ namespace detail
     public:
       friend class ::lzma_encoder;
 
-      typedef char                    char_type;
       typedef std::condition_variable event_type;
       typedef std::mutex              mutex_type;
 
@@ -33,8 +32,8 @@ namespace detail
         size_t lastBytesRead = _bytesRead;
 
         // set buffer pointer and get required size
-        _internalInputBuffer = static_cast<char_type*>(buf);
-        _internalBufferSize = *size / sizeof(char_type);
+        _internalInputBuffer = static_cast<uint8_t*>(buf);
+        _internalBufferSize = *size;
 
         // give control back to the main thread
         set_event();
@@ -59,13 +58,13 @@ namespace detail
     private:
       size_t      _bytesRead            = 0;
       size_t      _internalBufferSize   = 0;
-      char_type*  _internalInputBuffer  = nullptr;
+      uint8_t*    _internalInputBuffer  = nullptr;
       event_type  _event;
       mutex_type  _mutex;
       bool        _endOfStream          = false;
 
-      char_type* get_buffer_begin() { return _internalInputBuffer; }
-      char_type* get_buffer_end() { return _internalInputBuffer + _internalBufferSize; }
+      uint8_t* get_buffer_begin() { return _internalInputBuffer; }
+      uint8_t* get_buffer_end() { return _internalInputBuffer + _internalBufferSize; }
 
       void set_event()
       {

--- a/Source/ZipLib/compression/lzma/detail/lzma_out_stream.h
+++ b/Source/ZipLib/compression/lzma/detail/lzma_out_stream.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "../../../utils/stream/serialization.h"
 #include "../../../extlibs/lzma/Types.h"
 
 namespace detail
@@ -7,8 +8,6 @@ namespace detail
     : public ISeqOutStream
   {
     public:
-      typedef char char_type;
-
       lzma_out_stream()
       {
         this->Write = [](void* p, const void* buf, size_t size)
@@ -21,7 +20,7 @@ namespace detail
       size_t write(const void* buf, size_t size)
       {
         auto currentPosition = _stream->tellp();
-        _stream->write(reinterpret_cast<const char_type*>(buf), size);
+        utils::stream::serialize(*_stream, buf, size);
 
         size_t delta = static_cast<size_t>(_stream->tellp()) - static_cast<size_t>(currentPosition);
 

--- a/Source/ZipLib/compression/lzma/lzma_decoder.h
+++ b/Source/ZipLib/compression/lzma/lzma_decoder.h
@@ -1,9 +1,8 @@
 #pragma once
-#include "../compression_interface.h"
-
-#include "detail/lzma_alloc.h"
 #include "lzma_properties.h"
-
+#include "detail/lzma_alloc.h"
+#include "../compression_interface.h"
+#include "../../utils/stream/serialization.h"
 #include "../../extlibs/lzma/LzmaDec.h"
 
 #include <cstdint>
@@ -46,12 +45,12 @@ class lzma_decoder
       _bufferCapacity = lzmaProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
-      _outputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer  = new uint8_t[_bufferCapacity];
+      _outputBuffer = new uint8_t[_bufferCapacity];
 
       // read lzma header
-      Byte header[LZMA_PROPS_SIZE + 4];
-      _stream->read(reinterpret_cast<char_type*>(header), sizeof(header) / sizeof(char_type));
+      Byte header[detail::lzma_header::HEADER_SIZE];
+      utils::stream::deserialize(*_stream, header);
 
       // init lzma
       LzmaDec_Allocate(&_handle, &header[4], LZMA_PROPS_SIZE, &_alloc);
@@ -63,12 +62,12 @@ class lzma_decoder
       return (_inputBuffer != nullptr && _outputBuffer != nullptr);
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _outputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _outputBuffer + _outputBufferSize;
     }
@@ -122,7 +121,7 @@ class lzma_decoder
     void read_next()
     {
       // read next bytes from input stream
-      _stream->read(_inputBuffer, _bufferCapacity);
+      utils::stream::deserialize(*_stream, _inputBuffer, _bufferCapacity);
 
       // set the size of buffer
       _inputBufferSize = static_cast<size_t>(_stream->gcount());
@@ -143,6 +142,6 @@ class lzma_decoder
     size_t     _bufferCapacity    = 0;
     size_t     _inputBufferSize   = 0;        // how many bytes are read in the input buffer
     size_t     _outputBufferSize  = 0;        // how many bytes are written in the output buffer
-    char_type* _inputBuffer       = nullptr;  // pointer to the start of the input buffer
-    char_type* _outputBuffer      = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _inputBuffer       = nullptr;  // pointer to the start of the input buffer
+    uint8_t*   _outputBuffer      = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/compression/lzma/lzma_encoder.h
+++ b/Source/ZipLib/compression/lzma/lzma_encoder.h
@@ -1,13 +1,15 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "lzma_properties.h"
+
 #include "detail/lzma_alloc.h"
 #include "detail/lzma_handle.h"
 #include "detail/lzma_header.h"
 #include "detail/lzma_in_stream.h"
 #include "detail/lzma_out_stream.h"
 
+#include "../compression_interface.h"
+#include "../../utils/stream/serialization.h"
+
 #include <ostream>
 #include <thread>
 #include <cstdint>
@@ -50,12 +52,12 @@ class lzma_encoder
       return &_ostream.get_stream() != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _istream.get_buffer_begin();
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _istream.get_buffer_end();
     }

--- a/Source/ZipLib/compression/store/store_decoder.h
+++ b/Source/ZipLib/compression/store/store_decoder.h
@@ -1,9 +1,8 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "store_properties.h"
-
+#include "../compression_interface.h"
 #include "../../streams/crc32stream.h"
+#include "../../utils/stream/serialization.h"
 #include "../../extlibs/zlib/zlib.h"
 
 #include <cstdint>
@@ -44,7 +43,7 @@ class store_decoder
       _bufferCapacity = storeProps.BufferCapacity;
 
       uninit_buffers();
-      _outputBuffer = new char_type[_bufferCapacity];
+      _outputBuffer = new uint8_t[_bufferCapacity];
     }
 
     bool is_init() const override
@@ -52,12 +51,12 @@ class store_decoder
       return (_outputBuffer != nullptr);
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _outputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _outputBuffer + _outputBufferSize;
     }
@@ -65,7 +64,7 @@ class store_decoder
     size_t decode_next() override
     {
       // read next bytes from input stream
-      _stream->read(_outputBuffer, _bufferCapacity);
+      utils::stream::deserialize(*_stream, _outputBuffer, _bufferCapacity);
 
       // set the size of buffer
       _outputBufferSize = static_cast<size_t>(_stream->gcount());
@@ -84,5 +83,5 @@ class store_decoder
 
     size_t     _bufferCapacity    = 0;
     size_t     _outputBufferSize  = 0;        // how many bytes are written in the output buffer
-    char_type* _outputBuffer      = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _outputBuffer      = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/compression/store/store_encoder.h
+++ b/Source/ZipLib/compression/store/store_encoder.h
@@ -1,9 +1,8 @@
 #pragma once
-#include "../compression_interface.h"
-
 #include "store_properties.h"
-
+#include "../compression_interface.h"
 #include "../../streams/crc32stream.h"
+#include "../../utils/stream/serialization.h"
 #include "../../extlibs/zlib/zlib.h"
 
 #include <cstdint>
@@ -41,8 +40,8 @@ class store_encoder
       _bufferCapacity = storeProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
-      _outputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer  = new uint8_t[_bufferCapacity];
+      _outputBuffer = new uint8_t[_bufferCapacity];
     }
 
     bool is_init() const override
@@ -50,19 +49,19 @@ class store_encoder
       return _stream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
 
     void encode_next(size_t length) override
     {
-      _stream->write(_inputBuffer, length);
+      utils::stream::serialize(*_stream, _inputBuffer, length);
     }
 
     void sync() override
@@ -80,6 +79,6 @@ class store_encoder
     std::ostream* _stream       = nullptr;
 
     size_t     _bufferCapacity  = 0;
-    char_type* _inputBuffer     = nullptr;  // pointer to the start of the input buffer
-    char_type* _outputBuffer    = nullptr;  // pointer to the start of the output buffer
+    uint8_t*   _inputBuffer     = nullptr;  // pointer to the start of the input buffer
+    uint8_t*   _outputBuffer    = nullptr;  // pointer to the start of the output buffer
 };

--- a/Source/ZipLib/detail/EndOfCentralDirectoryBlock.cpp
+++ b/Source/ZipLib/detail/EndOfCentralDirectoryBlock.cpp
@@ -1,5 +1,5 @@
 #include "EndOfCentralDirectoryBlock.h"
-#include "../streams/serialization.h"
+#include "../utils/stream/serialization.h"
 #include <cstring>
 
 namespace detail {
@@ -15,21 +15,21 @@ bool EndOfCentralDirectoryBlock::Deserialize(std::istream& stream)
   // this condition should be optimized out :)
   if (sizeof(EndOfCentralDirectoryBlockBase) == EndOfCentralDirectoryBlockBase::SIZE_IN_BYTES)
   {
-    deserialize<EndOfCentralDirectoryBlockBase>(stream, *this);
+    utils::stream::deserialize<EndOfCentralDirectoryBlockBase>(stream, *this);
   }
   else
   {
-    deserialize(stream, Signature);
-    deserialize(stream, NumberOfThisDisk);
-    deserialize(stream, NumberOfTheDiskWithTheStartOfTheCentralDirectory);
-    deserialize(stream, NumberOfEntriesInTheCentralDirectoryOnThisDisk);
-    deserialize(stream, NumberOfEntriesInTheCentralDirectory);
-    deserialize(stream, SizeOfCentralDirectory);
-    deserialize(stream, OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber);
-    deserialize(stream, CommentLength);
+    utils::stream::deserialize(stream, Signature);
+    utils::stream::deserialize(stream, NumberOfThisDisk);
+    utils::stream::deserialize(stream, NumberOfTheDiskWithTheStartOfTheCentralDirectory);
+    utils::stream::deserialize(stream, NumberOfEntriesInTheCentralDirectoryOnThisDisk);
+    utils::stream::deserialize(stream, NumberOfEntriesInTheCentralDirectory);
+    utils::stream::deserialize(stream, SizeOfCentralDirectory);
+    utils::stream::deserialize(stream, OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber);
+    utils::stream::deserialize(stream, CommentLength);
   }
 
-  deserialize(stream, Comment, CommentLength);
+  utils::stream::deserialize(stream, Comment, CommentLength);
 
   return true;
 }
@@ -40,21 +40,21 @@ void EndOfCentralDirectoryBlock::Serialize(std::ostream& stream)
  
   if (sizeof(EndOfCentralDirectoryBlockBase) == EndOfCentralDirectoryBlockBase::SIZE_IN_BYTES)
   {
-    serialize<EndOfCentralDirectoryBlockBase>(stream, *this);
+    utils::stream::serialize<EndOfCentralDirectoryBlockBase>(stream, *this);
   }
   else
   {
-    serialize(stream, Signature);
-    serialize(stream, NumberOfThisDisk);
-    serialize(stream, NumberOfTheDiskWithTheStartOfTheCentralDirectory);
-    serialize(stream, NumberOfEntriesInTheCentralDirectoryOnThisDisk);
-    serialize(stream, NumberOfEntriesInTheCentralDirectory);
-    serialize(stream, SizeOfCentralDirectory);
-    serialize(stream, OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber);
-    serialize(stream, CommentLength);
+    utils::stream::serialize(stream, Signature);
+    utils::stream::serialize(stream, NumberOfThisDisk);
+    utils::stream::serialize(stream, NumberOfTheDiskWithTheStartOfTheCentralDirectory);
+    utils::stream::serialize(stream, NumberOfEntriesInTheCentralDirectoryOnThisDisk);
+    utils::stream::serialize(stream, NumberOfEntriesInTheCentralDirectory);
+    utils::stream::serialize(stream, SizeOfCentralDirectory);
+    utils::stream::serialize(stream, OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber);
+    utils::stream::serialize(stream, CommentLength);
   }
 
-  serialize(stream, Comment);
+  utils::stream::serialize(stream, Comment);
 }
 
 }

--- a/Source/ZipLib/detail/ZipCentralDirectoryFileHeader.cpp
+++ b/Source/ZipLib/detail/ZipCentralDirectoryFileHeader.cpp
@@ -1,7 +1,7 @@
 #include "ZipCentralDirectoryFileHeader.h"
 #include "ZipLocalFileHeader.h"
 
-#include "../streams/serialization.h"
+#include "../utils/stream/serialization.h"
 
 #include <cstring>
 #include <ctime>
@@ -28,27 +28,27 @@ bool ZipCentralDirectoryFileHeader::Deserialize(std::istream& stream)
 {
   if (sizeof(ZipCentralDirectoryFileHeaderBase) == ZipCentralDirectoryFileHeaderBase::SIZE_IN_BYTES)
   {
-    deserialize<ZipCentralDirectoryFileHeaderBase>(stream, *this);
+    utils::stream::deserialize<ZipCentralDirectoryFileHeaderBase>(stream, *this);
   }
   else
   {
-    deserialize(stream, Signature);
-    deserialize(stream, VersionMadeBy);
-    deserialize(stream, VersionNeededToExtract);
-    deserialize(stream, GeneralPurposeBitFlag);
-    deserialize(stream, CompressionMethod);
-    deserialize(stream, LastModificationTime);
-    deserialize(stream, LastModificationDate);
-    deserialize(stream, Crc32);
-    deserialize(stream, CompressedSize);
-    deserialize(stream, UncompressedSize);
-    deserialize(stream, FilenameLength);
-    deserialize(stream, ExtraFieldLength);
-    deserialize(stream, FileCommentLength);
-    deserialize(stream, DiskNumberStart);
-    deserialize(stream, InternalFileAttributes);
-    deserialize(stream, ExternalFileAttributes);
-    deserialize(stream, RelativeOffsetOfLocalHeader);
+    utils::stream::deserialize(stream, Signature);
+    utils::stream::deserialize(stream, VersionMadeBy);
+    utils::stream::deserialize(stream, VersionNeededToExtract);
+    utils::stream::deserialize(stream, GeneralPurposeBitFlag);
+    utils::stream::deserialize(stream, CompressionMethod);
+    utils::stream::deserialize(stream, LastModificationTime);
+    utils::stream::deserialize(stream, LastModificationDate);
+    utils::stream::deserialize(stream, Crc32);
+    utils::stream::deserialize(stream, CompressedSize);
+    utils::stream::deserialize(stream, UncompressedSize);
+    utils::stream::deserialize(stream, FilenameLength);
+    utils::stream::deserialize(stream, ExtraFieldLength);
+    utils::stream::deserialize(stream, FileCommentLength);
+    utils::stream::deserialize(stream, DiskNumberStart);
+    utils::stream::deserialize(stream, InternalFileAttributes);
+    utils::stream::deserialize(stream, ExternalFileAttributes);
+    utils::stream::deserialize(stream, RelativeOffsetOfLocalHeader);
   }
 
   // If there is not any other entry.
@@ -59,7 +59,7 @@ bool ZipCentralDirectoryFileHeader::Deserialize(std::istream& stream)
     return false;
   }
 
-  deserialize(stream, Filename, FilenameLength);
+  utils::stream::deserialize(stream, Filename, FilenameLength);
 
   if (ExtraFieldLength > 0)
   {
@@ -73,7 +73,7 @@ bool ZipCentralDirectoryFileHeader::Deserialize(std::istream& stream)
     }
   }
 
-  deserialize(stream, FileComment, FileCommentLength);
+  utils::stream::deserialize(stream, FileComment, FileCommentLength);
 
   return true;
 }
@@ -91,30 +91,30 @@ void ZipCentralDirectoryFileHeader::Serialize(std::ostream& stream)
 
   if (sizeof(ZipCentralDirectoryFileHeaderBase) == ZipCentralDirectoryFileHeaderBase::SIZE_IN_BYTES)
   {
-    serialize<ZipCentralDirectoryFileHeaderBase>(stream, *this);
+    utils::stream::serialize<ZipCentralDirectoryFileHeaderBase>(stream, *this);
   }
   else
   {
-    serialize(stream, Signature);
-    serialize(stream, VersionMadeBy);
-    serialize(stream, VersionNeededToExtract);
-    serialize(stream, GeneralPurposeBitFlag);
-    serialize(stream, CompressionMethod);
-    serialize(stream, LastModificationTime);
-    serialize(stream, LastModificationDate);
-    serialize(stream, Crc32);
-    serialize(stream, CompressedSize);
-    serialize(stream, UncompressedSize);
-    serialize(stream, FilenameLength);
-    serialize(stream, ExtraFieldLength);
-    serialize(stream, FileCommentLength);
-    serialize(stream, DiskNumberStart);
-    serialize(stream, InternalFileAttributes);
-    serialize(stream, ExternalFileAttributes);
-    serialize(stream, RelativeOffsetOfLocalHeader);
+    utils::stream::serialize(stream, Signature);
+    utils::stream::serialize(stream, VersionMadeBy);
+    utils::stream::serialize(stream, VersionNeededToExtract);
+    utils::stream::serialize(stream, GeneralPurposeBitFlag);
+    utils::stream::serialize(stream, CompressionMethod);
+    utils::stream::serialize(stream, LastModificationTime);
+    utils::stream::serialize(stream, LastModificationDate);
+    utils::stream::serialize(stream, Crc32);
+    utils::stream::serialize(stream, CompressedSize);
+    utils::stream::serialize(stream, UncompressedSize);
+    utils::stream::serialize(stream, FilenameLength);
+    utils::stream::serialize(stream, ExtraFieldLength);
+    utils::stream::serialize(stream, FileCommentLength);
+    utils::stream::serialize(stream, DiskNumberStart);
+    utils::stream::serialize(stream, InternalFileAttributes);
+    utils::stream::serialize(stream, ExternalFileAttributes);
+    utils::stream::serialize(stream, RelativeOffsetOfLocalHeader);
   }
 
-  serialize(stream, Filename);
+  utils::stream::serialize(stream, Filename);
 
   if (ExtraFieldLength > 0)
   {
@@ -124,7 +124,7 @@ void ZipCentralDirectoryFileHeader::Serialize(std::ostream& stream)
     }
   }
 
-  serialize(stream, FileComment);
+  utils::stream::serialize(stream, FileComment);
 }
 
 }

--- a/Source/ZipLib/detail/ZipGenericExtraField.cpp
+++ b/Source/ZipLib/detail/ZipGenericExtraField.cpp
@@ -1,5 +1,5 @@
 #include "ZipGenericExtraField.h"
-#include "../streams/serialization.h"
+#include "../utils/stream/serialization.h"
 
 namespace detail {
 
@@ -10,15 +10,15 @@ bool ZipGenericExtraField::Deserialize(std::istream& stream, std::istream::pos_t
     return false;
   }
 
-  deserialize(stream, Tag);
-  deserialize(stream, Size);
+  utils::stream::deserialize(stream, Tag);
+  utils::stream::deserialize(stream, Size);
 
   if ((extraFieldEnd - stream.tellg()) < Size)
   {
     return false;
   }
 
-  deserialize(stream, Data, Size);
+  utils::stream::deserialize(stream, Data, Size);
 
   return true;
 }
@@ -27,9 +27,9 @@ void ZipGenericExtraField::Serialize(std::ostream& stream)
 {
   Size = static_cast<uint16_t>(Data.size());
 
-  serialize(stream, Tag);
-  serialize(stream, Size);
-  serialize(stream, Data);
+  utils::stream::serialize(stream, Tag);
+  utils::stream::serialize(stream, Size);
+  utils::stream::serialize(stream, Data);
 }
 
 }

--- a/Source/ZipLib/detail/ZipLocalFileHeader.cpp
+++ b/Source/ZipLib/detail/ZipLocalFileHeader.cpp
@@ -1,7 +1,7 @@
 #include "ZipLocalFileHeader.h"
 #include "ZipCentralDirectoryFileHeader.h"
 
-#include "../streams/serialization.h"
+#include "../utils/stream/serialization.h"
 
 #include <cstring>
 
@@ -32,21 +32,21 @@ bool ZipLocalFileHeader::Deserialize(std::istream& stream)
 {
   if (sizeof(ZipLocalFileHeaderBase) == ZipLocalFileHeaderBase::SIZE_IN_BYTES)
   {
-    deserialize<ZipLocalFileHeaderBase>(stream, *this);
+    utils::stream::deserialize<ZipLocalFileHeaderBase>(stream, *this);
   }
   else
   {
-    deserialize(stream, Signature);
-    deserialize(stream, VersionNeededToExtract);
-    deserialize(stream, GeneralPurposeBitFlag);
-    deserialize(stream, CompressionMethod);
-    deserialize(stream, LastModificationTime);
-    deserialize(stream, LastModificationDate);
-    deserialize(stream, Crc32);
-    deserialize(stream, CompressedSize);
-    deserialize(stream, UncompressedSize);
-    deserialize(stream, FilenameLength);
-    deserialize(stream, ExtraFieldLength);
+    utils::stream::deserialize(stream, Signature);
+    utils::stream::deserialize(stream, VersionNeededToExtract);
+    utils::stream::deserialize(stream, GeneralPurposeBitFlag);
+    utils::stream::deserialize(stream, CompressionMethod);
+    utils::stream::deserialize(stream, LastModificationTime);
+    utils::stream::deserialize(stream, LastModificationDate);
+    utils::stream::deserialize(stream, Crc32);
+    utils::stream::deserialize(stream, CompressedSize);
+    utils::stream::deserialize(stream, UncompressedSize);
+    utils::stream::deserialize(stream, FilenameLength);
+    utils::stream::deserialize(stream, ExtraFieldLength);
   }
 
   // If there is not any other entry.
@@ -57,7 +57,7 @@ bool ZipLocalFileHeader::Deserialize(std::istream& stream)
     return false;
   }
 
-  deserialize(stream, Filename, FilenameLength);
+  utils::stream::deserialize(stream, Filename, FilenameLength);
 
   if (ExtraFieldLength > 0)
   {
@@ -86,24 +86,24 @@ void ZipLocalFileHeader::Serialize(std::ostream& stream)
 
   if (sizeof(ZipLocalFileHeaderBase) == ZipLocalFileHeaderBase::SIZE_IN_BYTES)
   {
-    serialize<ZipLocalFileHeaderBase>(stream, *this);
+    utils::stream::serialize<ZipLocalFileHeaderBase>(stream, *this);
   }
   else
   {
-    serialize(stream, Signature);
-    serialize(stream, VersionNeededToExtract);
-    serialize(stream, GeneralPurposeBitFlag);
-    serialize(stream, CompressionMethod);
-    serialize(stream, LastModificationTime);
-    serialize(stream, LastModificationDate);
-    serialize(stream, Crc32);
-    serialize(stream, CompressedSize);
-    serialize(stream, UncompressedSize);
-    serialize(stream, FilenameLength);
-    serialize(stream, ExtraFieldLength);
+    utils::stream::serialize(stream, Signature);
+    utils::stream::serialize(stream, VersionNeededToExtract);
+    utils::stream::serialize(stream, GeneralPurposeBitFlag);
+    utils::stream::serialize(stream, CompressionMethod);
+    utils::stream::serialize(stream, LastModificationTime);
+    utils::stream::serialize(stream, LastModificationDate);
+    utils::stream::serialize(stream, Crc32);
+    utils::stream::serialize(stream, CompressedSize);
+    utils::stream::serialize(stream, UncompressedSize);
+    utils::stream::serialize(stream, FilenameLength);
+    utils::stream::serialize(stream, ExtraFieldLength);
   }
 
-  serialize(stream, Filename);
+  utils::stream::serialize(stream, Filename);
 
   if (ExtraFieldLength > 0)
   {
@@ -117,29 +117,29 @@ void ZipLocalFileHeader::Serialize(std::ostream& stream)
 void ZipLocalFileHeader::DeserializeAsDataDescriptor(std::istream& stream)
 {
   uint32_t firstWord;
-  deserialize(stream, firstWord);
+  utils::stream::deserialize(stream, firstWord);
 
   // the signature is optional, if it's missing,
   // we're starting with crc32
   if (firstWord != DataDescriptorSignature)
   {
-    deserialize(stream, Crc32);
+    utils::stream::deserialize(stream, Crc32);
   }
   else
   {
     Crc32 = firstWord;
   }
 
-  deserialize(stream, CompressedSize);
-  deserialize(stream, UncompressedSize);
+  utils::stream::deserialize(stream, CompressedSize);
+  utils::stream::deserialize(stream, UncompressedSize);
 }
 
 void ZipLocalFileHeader::SerializeAsDataDescriptor(std::ostream& stream)
 {
-  serialize(stream, DataDescriptorSignature);
-  serialize(stream, Crc32);
-  serialize(stream, CompressedSize);
-  serialize(stream, UncompressedSize);
+  utils::stream::serialize(stream, DataDescriptorSignature);
+  utils::stream::serialize(stream, Crc32);
+  utils::stream::serialize(stream, CompressedSize);
+  utils::stream::serialize(stream, UncompressedSize);
 }
 
 }

--- a/Source/ZipLib/encryption/aes/aes_decoder.h
+++ b/Source/ZipLib/encryption/aes/aes_decoder.h
@@ -1,8 +1,8 @@
 #pragma once
-#include "../encryption_interface.h"
-#include "../../streams/serialization.h"
 #include "aes_properties.h"
 #include "detail/aes_impl.h"
+#include "../encryption_interface.h"
+#include "../../utils/stream/serialization.h"
 
 #include <cstdint>
 
@@ -36,7 +36,7 @@ class aes_decoder
       _bufferCapacity = aesProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer = new uint8_t[_bufferCapacity];
 
       // init stream
       _stream = &stream;
@@ -61,22 +61,22 @@ class aes_decoder
       return _stream != nullptr && _encryptedStream != nullptr && _authCodeStream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
 
     size_t decrypt_next() override
     {
-      _encryptedStream->read(_inputBuffer, _bufferCapacity);
+      utils::stream::deserialize(*_encryptedStream, _inputBuffer, _bufferCapacity);
 
       size_t n = static_cast<size_t>(_encryptedStream->gcount());
-      _aes.decrypt(reinterpret_cast<uint8_t*>(_inputBuffer), n);
+      _aes.decrypt(_inputBuffer, n);
 
       _aesContext.authcode = _aes.finish();
 
@@ -115,15 +115,15 @@ class aes_decoder
 
     void read_encryption_header()
     {
-      deserialize(*_encryptedStream, _aesStoredContext.salt.data(), _aesStoredContext.salt.size());
-      deserialize(*_encryptedStream, _aesStoredContext.passverify);
+      utils::stream::deserialize(*_encryptedStream, _aesStoredContext.salt.data(), _aesStoredContext.salt.size());
+      utils::stream::deserialize(*_encryptedStream, _aesStoredContext.passverify);
 
       _encryptionHeaderRead = true;
     }
 
     void read_encryption_footer()
     {
-      deserialize(*_authCodeStream, _aesStoredContext.authcode);
+      utils::stream::deserialize(*_authCodeStream, _aesStoredContext.authcode);
 
       _encryptionFooterRead = true;
     }
@@ -133,10 +133,10 @@ class aes_decoder
       delete[] _inputBuffer;
     }
 
-    char_type* _inputBuffer = nullptr;
-    size_t     _bufferCapacity = 0;
+    uint8_t*    _inputBuffer    = nullptr;
+    size_t     _bufferCapacity  = 0;
 
-    std::istream* _stream = nullptr;
+    std::istream* _stream       = nullptr;
     std::unique_ptr<isubstream> _encryptedStream;
     std::unique_ptr<isubstream> _authCodeStream;
 
@@ -157,6 +157,6 @@ class aes_decoder
     aes_context         _aesContext;
     aes_stored_context  _aesStoredContext;
 
-    bool _encryptionHeaderRead = false;
-    bool _encryptionFooterRead = false;
+    bool _encryptionHeaderRead  = false;
+    bool _encryptionFooterRead  = false;
 };

--- a/Source/ZipLib/encryption/aes/aes_encoder.h
+++ b/Source/ZipLib/encryption/aes/aes_encoder.h
@@ -1,8 +1,8 @@
 #pragma once
-#include "../encryption_interface.h"
-#include "../../streams/serialization.h"
 #include "aes_properties.h"
 #include "detail/aes_impl.h"
+#include "../encryption_interface.h"
+#include "../../utils/stream/serialization.h"
 
 #include <cstdint>
 
@@ -36,7 +36,7 @@ class aes_encoder
       _bufferCapacity = aesProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer = new uint8_t[_bufferCapacity];
 
       // init stream
       _stream = &stream;
@@ -54,12 +54,12 @@ class aes_encoder
       return _stream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
@@ -71,21 +71,21 @@ class aes_encoder
         write_encryption_header();
       }
 
-      _aes.encrypt(reinterpret_cast<uint8_t*>(_inputBuffer), length);
-      _stream->write(_inputBuffer, length);
+      _aes.encrypt(_inputBuffer, length);
+      utils::stream::serialize(*_stream, _inputBuffer, length);
     }
 
     void sync() override
     {
-      serialize(*_stream, _aes.finish());
+      utils::stream::serialize(*_stream, _aes.finish());
       _stream->rdbuf()->pubsync();
     }
 
   private:
     void write_encryption_header()
     {
-      serialize(*_stream, _aesContext.salt.data(), _aesContext.salt.size());
-      serialize(*_stream, _aesContext.passverify);
+      utils::stream::serialize(*_stream, _aesContext.salt.data(), _aesContext.salt.size());
+      utils::stream::serialize(*_stream, _aesContext.passverify);
 
       _encryptionHeaderWritten = true;
     }
@@ -95,7 +95,7 @@ class aes_encoder
       delete[] _inputBuffer;
     }
 
-    char_type* _inputBuffer = nullptr;
+    uint8_t*   _inputBuffer = nullptr;
     size_t     _bufferCapacity = 0;
 
     std::ostream* _stream = nullptr;

--- a/Source/ZipLib/encryption/aes/detail/aes_types.h
+++ b/Source/ZipLib/encryption/aes/detail/aes_types.h
@@ -6,9 +6,9 @@ namespace detail {
 
   enum
   {
-    AES_PASSWORD_VERIFY_SIZE = 2,
-    AES_AUTHCODE_SIZE = 10,
-    AES_MAX_SALT_LENGTH = 16
+    AES_PASSWORD_VERIFY_SIZE  = 2,
+    AES_AUTHCODE_SIZE         = 10,
+    AES_MAX_SALT_LENGTH       = 16
   };
 
   using aes_passverify = std::array<uint8_t, AES_PASSWORD_VERIFY_SIZE>;

--- a/Source/ZipLib/encryption/encryption_interface.h
+++ b/Source/ZipLib/encryption/encryption_interface.h
@@ -21,14 +21,12 @@ struct encryption_properties_interface
 class encryption_interface
 {
   public:
-    typedef char char_type;
-
     virtual ~encryption_interface() { }
 
     virtual bool is_init() const = 0;
 
-    virtual char_type* get_buffer_begin() = 0;
-    virtual char_type* get_buffer_end() = 0;
+    virtual uint8_t* get_buffer_begin() = 0;
+    virtual uint8_t* get_buffer_end() = 0;
 };
 
 class encryption_encoder_interface

--- a/Source/ZipLib/encryption/zipcrypto/zipcrypto_decoder.h
+++ b/Source/ZipLib/encryption/zipcrypto/zipcrypto_decoder.h
@@ -1,8 +1,9 @@
 #pragma once
-#include "../encryption_interface.h"
 #include "zipcrypto_properties.h"
-#include "../../extlibs/zlib/zconf.h"
 #include "detail/zipcrypto.h"
+#include "../encryption_interface.h"
+#include "../../utils/stream/serialization.h"
+#include "../../extlibs/zlib/zconf.h"
 
 #include <cstdint>
 
@@ -36,7 +37,7 @@ class zipcrypto_decoder
       _bufferCapacity = zipcryptoProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer = new uint8_t[_bufferCapacity];
 
       // init stream
       _stream = &stream;
@@ -57,12 +58,12 @@ class zipcrypto_decoder
       return _stream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
@@ -74,10 +75,10 @@ class zipcrypto_decoder
         read_encryption_header();
       }
 
-      _stream->read(_inputBuffer, _bufferCapacity);
+      utils::stream::deserialize(*_stream, _inputBuffer, _bufferCapacity);
 
       size_t n = static_cast<size_t>(_stream->gcount());
-      _zipcrypto.decrypt_buffer(reinterpret_cast<uint8_t*>(_inputBuffer), n);
+      _zipcrypto.decrypt_buffer(_inputBuffer, n);
 
       return n;
     }
@@ -90,9 +91,10 @@ class zipcrypto_decoder
   private:
     void read_encryption_header()
     {
-      _stream->read(
-        reinterpret_cast<char_type*>(&_zipcrypto.get_encryption_header()),
-        _zipcrypto.get_encryption_header_size());
+      utils::stream::deserialize(
+        *_stream,
+        &_zipcrypto.get_encryption_header(),
+         _zipcrypto.get_encryption_header_size());
 
       _zipcrypto.decrypt_header();
       _encryptionHeaderRead = true;
@@ -103,10 +105,10 @@ class zipcrypto_decoder
       delete[] _inputBuffer;
     }
 
-    char_type* _inputBuffer = nullptr;
-    size_t     _bufferCapacity = 0;
+    uint8_t*   _inputBuffer     = nullptr;
+    size_t     _bufferCapacity  = 0;
 
-    std::istream* _stream = nullptr;
+    std::istream* _stream       = nullptr;
     detail::zipcrypto _zipcrypto;
-    bool _encryptionHeaderRead = false;
+    bool _encryptionHeaderRead  = false;
 };

--- a/Source/ZipLib/encryption/zipcrypto/zipcrypto_encoder.h
+++ b/Source/ZipLib/encryption/zipcrypto/zipcrypto_encoder.h
@@ -1,7 +1,8 @@
 #pragma once
-#include "../encryption_interface.h"
 #include "zipcrypto_properties.h"
 #include "detail/zipcrypto.h"
+#include "../encryption_interface.h"
+#include "../../utils/stream/serialization.h"
 
 #include <cstdint>
 
@@ -35,7 +36,7 @@ class zipcrypto_encoder
       _bufferCapacity = zipcryptoProps.BufferCapacity;
 
       uninit_buffers();
-      _inputBuffer = new char_type[_bufferCapacity];
+      _inputBuffer = new uint8_t[_bufferCapacity];
 
       // init stream
       _stream = &stream;
@@ -53,12 +54,12 @@ class zipcrypto_encoder
       return _stream != nullptr;
     }
 
-    char_type* get_buffer_begin() override
+    uint8_t* get_buffer_begin() override
     {
       return _inputBuffer;
     }
 
-    char_type* get_buffer_end() override
+    uint8_t* get_buffer_end() override
     {
       return _inputBuffer + _bufferCapacity;
     }
@@ -70,8 +71,8 @@ class zipcrypto_encoder
         write_encryption_header();
       }
 
-      _zipcrypto.encrypt_buffer(reinterpret_cast<uint8_t*>(_inputBuffer), length);
-      _stream->write(_inputBuffer, length);
+      _zipcrypto.encrypt_buffer(_inputBuffer, length);
+      utils::stream::serialize(*_stream, _inputBuffer, length);
     }
 
     void sync() override
@@ -83,9 +84,11 @@ class zipcrypto_encoder
     void write_encryption_header()
     {
       _zipcrypto.encrypt_header();
-      _stream->write(
-        reinterpret_cast<const char_type*>(&_zipcrypto.get_encryption_header()),
-        _zipcrypto.get_encryption_header_size());
+
+      utils::stream::serialize(
+        *_stream,
+        &_zipcrypto.get_encryption_header(),
+         _zipcrypto.get_encryption_header_size());
 
       _encryptionHeaderWritten = true;
     }
@@ -95,7 +98,7 @@ class zipcrypto_encoder
       delete[] _inputBuffer;
     }
 
-    char_type* _inputBuffer       = nullptr;
+    uint8_t*   _inputBuffer       = nullptr;
     size_t     _bufferCapacity    = 0;
 
     std::ostream* _stream         = nullptr;

--- a/Source/ZipLib/extlibs/aes/aes.vcxproj
+++ b/Source/ZipLib/extlibs/aes/aes.vcxproj
@@ -114,6 +114,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -127,6 +128,7 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

--- a/Source/ZipLib/extlibs/bzip2/bzip2.vcxproj
+++ b/Source/ZipLib/extlibs/bzip2/bzip2.vcxproj
@@ -104,6 +104,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;BZ_NO_STDIO;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996; 4244</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -118,6 +119,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;BZ_NO_STDIO;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996; 4244</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

--- a/Source/ZipLib/extlibs/lzma/lzma.vcxproj
+++ b/Source/ZipLib/extlibs/lzma/lzma.vcxproj
@@ -160,6 +160,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -174,6 +175,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

--- a/Source/ZipLib/extlibs/zlib/zlib.vcxproj
+++ b/Source/ZipLib/extlibs/zlib/zlib.vcxproj
@@ -116,6 +116,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -130,6 +131,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DisableSpecificWarnings>4996</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

--- a/Source/ZipLib/methods/encryption/detail/AesExtraField.h
+++ b/Source/ZipLib/methods/encryption/detail/AesExtraField.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../../../detail/ZipGenericExtraField.h"
 #include "../../../streams/memstream.h"
-#include "../../../streams/serialization.h"
+#include "../../../utils/stream/serialization.h"
 #include <cstdint>
 
 namespace detail {
@@ -36,10 +36,10 @@ namespace detail {
 
       uint16_t dummyVendorID;
 
-      deserialize(extraFieldDataStream, AesVersion);
-      deserialize(extraFieldDataStream, dummyVendorID);
-      deserialize(extraFieldDataStream, EncryptionMode);
-      deserialize(extraFieldDataStream, CompressionMethod);
+      utils::stream::deserialize(extraFieldDataStream, AesVersion);
+      utils::stream::deserialize(extraFieldDataStream, dummyVendorID);
+      utils::stream::deserialize(extraFieldDataStream, EncryptionMode);
+      utils::stream::deserialize(extraFieldDataStream, CompressionMethod);
     }
 
     void ToExtraField(detail::ZipGenericExtraField& extraField)
@@ -51,10 +51,10 @@ namespace detail {
 
       omemstream extraFieldDataStream((char*)extraField.Data.data(), extraField.Data.size());
 
-      serialize(extraFieldDataStream, AesVersion);
-      serialize(extraFieldDataStream, VendorID);
-      serialize(extraFieldDataStream, EncryptionMode);
-      serialize(extraFieldDataStream, CompressionMethod);
+      utils::stream::serialize(extraFieldDataStream, AesVersion);
+      utils::stream::serialize(extraFieldDataStream, VendorID);
+      utils::stream::serialize(extraFieldDataStream, EncryptionMode);
+      utils::stream::serialize(extraFieldDataStream, CompressionMethod);
     }
   };
 

--- a/Source/ZipLib/streams/streambuffs/compression_decoder_streambuf.h
+++ b/Source/ZipLib/streams/streambuffs/compression_decoder_streambuf.h
@@ -35,7 +35,7 @@ class compression_decoder_streambuf
       _compressionDecoder->init(stream);
 
       // set stream buffer
-      this->setg(_compressionDecoder->get_buffer_end(), _compressionDecoder->get_buffer_end(), _compressionDecoder->get_buffer_end());
+      this->setg(get_buffer_end(), get_buffer_end(), get_buffer_end());
     }
 
     void init(compression_decoder_interface_ptr compressionDecoder, compression_properties_interface& props, std::istream& stream)
@@ -46,7 +46,7 @@ class compression_decoder_streambuf
       _compressionDecoder->init(stream, props);
 
       // set stream buffer
-      this->setg(_compressionDecoder->get_buffer_end(), _compressionDecoder->get_buffer_end(), _compressionDecoder->get_buffer_end());
+      this->setg(get_buffer_end(), get_buffer_end(), get_buffer_end());
     }
 
     bool is_init() const
@@ -60,7 +60,7 @@ class compression_decoder_streambuf
       // buffer exhausted
       if (this->gptr() >= this->egptr())
       {
-        char_type* base = _compressionDecoder->get_buffer_begin();
+        char_type* base = get_buffer_begin();
 
         // how many bytes has been read
         size_t n = _compressionDecoder->decode_next();
@@ -78,5 +78,15 @@ class compression_decoder_streambuf
     }
 
   private:
+    char_type* get_buffer_begin()
+    {
+      return reinterpret_cast<char_type*>(_compressionDecoder->get_buffer_begin());
+    }
+
+    char_type* get_buffer_end()
+    {
+      return reinterpret_cast<char_type*>(_compressionDecoder->get_buffer_end());
+    }
+
     compression_decoder_interface_ptr _compressionDecoder;
 };

--- a/Source/ZipLib/streams/streambuffs/compression_encoder_streambuf.h
+++ b/Source/ZipLib/streams/streambuffs/compression_encoder_streambuf.h
@@ -40,7 +40,7 @@ class compression_encoder_streambuf
       _compressionEncoder->init(stream);
 
       // set stream buffer
-      this->setp(_compressionEncoder->get_buffer_begin(), _compressionEncoder->get_buffer_end() - 1);
+      this->setp(get_buffer_begin(), get_buffer_end() - 1);
     }
 
     void init(compression_encoder_interface_ptr compressionEncoder, compression_properties_interface& props, std::ostream& stream)
@@ -51,7 +51,7 @@ class compression_encoder_streambuf
       _compressionEncoder->init(stream, props);
 
       // set stream buffer
-      this->setp(_compressionEncoder->get_buffer_begin(), _compressionEncoder->get_buffer_end() - 1);
+      this->setp(get_buffer_begin(), get_buffer_end() - 1);
     }
 
     bool is_init() const
@@ -98,7 +98,17 @@ class compression_encoder_streambuf
       _compressionEncoder->encode_next(inputLength);
 
       // set pointers for new buffer
-      this->setp(_compressionEncoder->get_buffer_begin(), _compressionEncoder->get_buffer_end() - 1);
+      this->setp(get_buffer_begin(), get_buffer_end() - 1);
+    }
+
+    char_type* get_buffer_begin()
+    {
+      return reinterpret_cast<char_type*>(_compressionEncoder->get_buffer_begin());
+    }
+
+    char_type* get_buffer_end()
+    {
+      return reinterpret_cast<char_type*>(_compressionEncoder->get_buffer_end());
     }
 
     compression_encoder_interface_ptr _compressionEncoder;

--- a/Source/ZipLib/streams/streambuffs/encryption_decoder_streambuf.h
+++ b/Source/ZipLib/streams/streambuffs/encryption_decoder_streambuf.h
@@ -35,7 +35,7 @@ class encryption_decoder_streambuf
       _encryptionDecoder->init(stream);
 
       // set stream buffer
-      this->setg(_encryptionDecoder->get_buffer_end(), _encryptionDecoder->get_buffer_end(), _encryptionDecoder->get_buffer_end());
+      this->setg(get_buffer_end(), get_buffer_end(), get_buffer_end());
     }
 
     void init(encryption_decoder_interface_ptr encryptionDecoder, encryption_properties_interface& props, std::istream& stream)
@@ -46,7 +46,7 @@ class encryption_decoder_streambuf
       _encryptionDecoder->init(stream, props);
 
       // set stream buffer
-      this->setg(_encryptionDecoder->get_buffer_end(), _encryptionDecoder->get_buffer_end(), _encryptionDecoder->get_buffer_end());
+      this->setg(get_buffer_end(), get_buffer_end(), get_buffer_end());
     }
 
     bool is_init() const
@@ -60,7 +60,7 @@ class encryption_decoder_streambuf
       // buffer exhausted
       if (this->gptr() >= this->egptr())
       {
-        char_type* base = _encryptionDecoder->get_buffer_begin();
+        char_type* base = get_buffer_begin();
 
         // how many bytes has been read
         size_t n = _encryptionDecoder->decrypt_next();
@@ -78,5 +78,15 @@ class encryption_decoder_streambuf
     }
 
   private:
+    char_type* get_buffer_begin()
+    {
+      return reinterpret_cast<char_type*>(_encryptionDecoder->get_buffer_begin());
+    }
+
+    char_type* get_buffer_end()
+    {
+      return reinterpret_cast<char_type*>(_encryptionDecoder->get_buffer_end());
+    }
+
     encryption_decoder_interface_ptr _encryptionDecoder;
 };

--- a/Source/ZipLib/streams/streambuffs/encryption_encoder_streambuf.h
+++ b/Source/ZipLib/streams/streambuffs/encryption_encoder_streambuf.h
@@ -40,7 +40,7 @@ class encryption_encoder_streambuf
       _encryptionEncoder->init(stream);
 
       // set stream buffer
-      this->setp(_encryptionEncoder->get_buffer_begin(), _encryptionEncoder->get_buffer_end() - 1);
+      this->setp(get_buffer_begin(), get_buffer_end() - 1);
     }
 
     void init(encryption_encoder_interface_ptr encryptionEncoder, encryption_properties_interface& props, std::ostream& stream)
@@ -51,7 +51,7 @@ class encryption_encoder_streambuf
       _encryptionEncoder->init(stream, props);
 
       // set stream buffer
-      this->setp(_encryptionEncoder->get_buffer_begin(), _encryptionEncoder->get_buffer_end() - 1);
+      this->setp(get_buffer_begin(), get_buffer_end() - 1);
     }
 
     bool is_init() const
@@ -98,7 +98,17 @@ class encryption_encoder_streambuf
       _encryptionEncoder->encrypt_next(inputLength);
 
       // set pointers for new buffer
-      this->setp(_encryptionEncoder->get_buffer_begin(), _encryptionEncoder->get_buffer_end() - 1);
+      this->setp(get_buffer_begin(), get_buffer_end() - 1);
+    }
+
+    char_type* get_buffer_begin()
+    {
+      return reinterpret_cast<char_type*>(_encryptionEncoder->get_buffer_begin());
+    }
+
+    char_type* get_buffer_end()
+    {
+      return reinterpret_cast<char_type*>(_encryptionEncoder->get_buffer_end());
     }
 
     encryption_encoder_interface_ptr _encryptionEncoder;

--- /dev/null
+++ b/Source/ZipLib/utils/stream/copy.h
@@ -0,0 +1,18 @@
+#pragma once
+#include <iostream>
+#include <vector>
+
+namespace utils { namespace stream {
+
+static void copy(std::istream& from, std::ostream& to, size_t bufferSize = 1024 * 1024)
+{
+  std::vector<char> buff(bufferSize);
+
+  do
+  {
+    from.read(buff.data(), buff.size());
+    to.write(buff.data(), from.gcount());
+  } while (static_cast<size_t>(from.gcount()) == buff.size());
+}
+
+} }

--- a/Source/ZipLib/streams/serialization.h
+++ b/Source/ZipLib/utils/stream/serialization.h
@@ -5,6 +5,8 @@
 #include <array>
 #include <list>
 
+namespace utils { namespace stream {
+
 namespace detail {
 
   template <typename CONTAINER_TYPE>
@@ -58,6 +60,20 @@ void serialize(std::basic_ostream<ELEM_TYPE, TRAITS_TYPE>& stream, const TYPE& v
 }
 
 /**
+ * \brief Serializes native array of the input type.
+ *
+ * \tparam  TYPE      Type of the value to be serialized.
+ * \tparam  N         Deducted array size.
+ * \param   stream    The stream to be serialized into.
+ * \param   value     The value to be serialized.
+ */
+template <typename TYPE, size_t N, typename ELEM_TYPE, typename TRAITS_TYPE>
+void serialize(std::basic_ostream<ELEM_TYPE, TRAITS_TYPE>& stream, const TYPE(&value)[N])
+{
+  stream.write(reinterpret_cast<const ELEM_TYPE*>(value), N * (sizeof(TYPE) / sizeof(ELEM_TYPE)));
+}
+
+/**
  * \brief Serializes the input type of specified size
  *
  * \tparam  TYPE      Type of the value to be serialized.
@@ -135,6 +151,23 @@ std::ios::pos_type deserialize(std::basic_istream<ELEM_TYPE, TRAITS_TYPE>& strea
 }
 
 /**
+ * \brief Deserializes native array of the input type.
+ *
+ * \tparam  RETURN_TYPE  Type of the value to be deserialized.
+ * \tparam  N            Deducted array size.
+ * \param   stream       The stream to be deserialized from.
+ * \param   [out] out    The deserialized value.
+ *
+ * \return  Count of read elements.
+ */
+template <typename RETURN_TYPE, size_t N, typename ELEM_TYPE, typename TRAITS_TYPE>
+std::ios::pos_type deserialize(std::basic_istream<ELEM_TYPE, TRAITS_TYPE>& stream, RETURN_TYPE(&out)[N])
+{
+  stream.read(reinterpret_cast<ELEM_TYPE*>(out), N * sizeof(RETURN_TYPE));
+  return stream.gcount();
+}
+
+/**
  * \brief Deserializes the input type from the stream
  *
  * \tparam  RETURN_TYPE  Type of the value to be deserialized.
@@ -204,4 +237,6 @@ template <typename ELEM_TYPE, typename TRAITS_TYPE, typename ARRAY_ELEM_TYPE, si
 std::ios::pos_type deserialize(std::basic_istream<ELEM_TYPE, TRAITS_TYPE>& stream, std::array<ARRAY_ELEM_TYPE, ARRAY_SIZE>& out)
 {
   return detail::deserialize_stl_container(stream, out, out.size());
-}
\ No newline at end of file
+}
+
+} }

--- a/Source/ZipLib/utils/stream_utils.h
+++ b/Source/ZipLib/utils/stream_utils.h
@@ -1,18 +1,3 @@
 #pragma once
-#include <iostream>
-#include <vector>
-
-namespace utils { namespace stream {
-
-static void copy(std::istream& from, std::ostream& to, size_t bufferSize = 1024 * 1024)
-{
-  std::vector<char> buff(bufferSize);
-
-  do
-  {
-    from.read(buff.data(), buff.size());
-    to.write(buff.data(), from.gcount());
-  } while (static_cast<size_t>(from.gcount()) == buff.size());
-}
-
-} }
+#include "stream/copy.h"
+#include "stream/serialization.h"