make use of better datastructures

src/main/kotlin/edu/ba/twoDimensionalRLE/encoder/mixed/MixedEncoder.kt

@@ -132,7 +132,7 @@ class MixedEncoder : Encoder {
         var totalSize = input.length()
         val huffmanEncoder = HuffmanEncoder()
         var chunks = DataChunk.readChunksFromFile(inputFile, byteArraySize, log)
-        val huffBuffer = StringBuffer()
+        val huffBuffer = mutableListOf<Boolean>()
 
         analyzer.analyzeFile(input)
         analyzer.addBWTSymbolsToMapping()
@@ -158,15 +158,15 @@ class MixedEncoder : Encoder {
 
         printEncodingInfo()
 
-        log.info("Collecting all bytes to encode with huffman encoding to build dictionary...")
+        log.info("Collecting all bits to encode with huffman encoding to build dictionary...")
         //TODO improve buffer collecting
         chunks.forEach {
             for (i in HUFF_BIT_RANGE) {
-                huffBuffer.append(it.getLineFromChunkAsStringBuffer(i))
+                huffBuffer.addAll(it.getLineFromChunkAsBoolList(i))
             }
         }
 
-        log.debug("Creating byte array from ${huffBuffer.length} bit large buffer...")
+        log.debug("Creating byte array from ${huffBuffer.size} bit large buffer...")
         //TODO create better mapping creation to use less ram
         val huffBufferArray = huffBuffer.toByteArray()
         val huffmanMapping = huffmanEncoder.getHuffmanMapping(256, huffBufferArray)

src/main/kotlin/edu/ba/twoDimensionalRLE/extensions/ListExtensions.kt

@@ -0,0 +1,18 @@
+package edu.ba.twoDimensionalRLE.extensions
+
+
+fun List<Boolean>.toByteArray(): ByteArray {
+    var result = ByteArray(0)
+
+    this.chunked(8).forEach { chunk ->
+        var chunkValue = 0
+        chunk.forEachIndexed { index , bit ->
+            if (bit) {
+                chunkValue += 2.pow(index)
+            }
+        }
+
+        result += chunkValue.toByte()
+    }
+    return result
+}

src/main/kotlin/edu/ba/twoDimensionalRLE/model/DataChunk.kt

@@ -55,11 +55,11 @@ open class DataChunk(val input: ByteArray) {
             rleRange: IntRange,
             huffRange: IntRange,
             huffDecodedBytes: ByteArray,
-            binRleBuffer: StringBuffer,
+            binRleBuffer: List<Boolean>,
             log: Logger
         ): List<DataChunk> {
             log.info("Starting to reconstruct DataChunks from parsed buffers...")
-            var currentLinesOfChunk = mutableMapOf<Int, String>()
+            var currentLinesOfChunk = mutableMapOf<Int, List<Boolean>>()
             var remainingSize = totalSize
 
             log.info("Building buffer from bytes...")
@@ -79,13 +79,13 @@ open class DataChunk(val input: ByteArray) {
 
                     //build bin rle decoded lines
                     binRleRange.forEach { line ->
-                        currentLinesOfChunk[line] = binRleBuffer.substring(0, currentLength)
-                        binRleBuffer.delete(0, currentLength)
+                        currentLinesOfChunk[line] = binRleBuffer.subList(0, currentLength)
+                        binRleBuffer.subList(currentLength, binRleBuffer.size)
                     }
 
                     //huff decoded lines
                     huffRange.forEach { line ->
-                        currentLinesOfChunk[line] = remainingHuffmanBuffer.substring(0, currentLength)
+                        currentLinesOfChunk[line] = remainingHuffmanBuffer.subSequence(0, currentLength)
                         remainingHuffmanBuffer.delete(0, currentLength)
                     }
 
@@ -153,6 +153,18 @@ open class DataChunk(val input: ByteArray) {
         return bits
     }
 
+    fun getLineFromChunkAsBoolList(line: Int): List<Boolean> {
+        val bits = mutableListOf<Boolean>()
+        bytes.forEach { byte ->
+            if (byte.toInt().shl(7 - line).toUByte().toInt().shr(7) == 1) {
+                bits.add(true)
+            } else {
+                bits.add(false)
+            }
+        }
+        return bits
+    }
+
     fun applyByteMapping(mapping: Map<Byte, Byte>): DataChunk {
         val result = mutableListOf<Byte>()
         bytes.forEach { byte ->