chore: Refactor

Author: ayonious

logs/file-compression.log

@@ -50,6 +50,17 @@ public class HuffmanCompressor implements Compressor {
 	 */
 	private HuffmanNode huffmanTree;
 
+
+	/**
+	 * Byte reader for the input file
+	 */
+	private ByteReader byteReader;
+
+	/**
+	 * Byte writer for the output file
+	 */
+	private ByteWriter byteWriter;
+
 	/**
 	 * Constructor that takes a file path and generates Huffman codes and frequency
 	 * @param inputFilePath The path to the file to be compressed
@@ -68,34 +79,43 @@ public HuffmanCompressor(String inputFilePath) {
 		logger.debug("Building Huffman tree");
 		this.huffmanTree = HuffmanUtils.buildHuffmanTree(frequency);
 		this.huffmanCodes = HuffmanUtils.generateHuffmanCodes(huffmanTree);
+
+		try {
+			this.byteReader = new ByteReader(inputFilePath);
+			this.byteWriter = new ByteWriter(outputFilePath);
+		} catch (IOException e) {
+			logger.error("Failed to initialize byte reader and writer: {}", e.getMessage());
+			throw new RuntimeException("Failed to initialize byte reader and writer: " + e.getMessage());
+		}
+
 		logger.debug("Huffman codes generated successfully");
 	}
 	/**********************************************************************************/
 
 	/**
 	 * Step 1: Write the table size
 	 */
-	private void writeTableSize(ByteWriter writer) throws IOException {
-		writer.writeInt(HuffmanUtils.calculateUniqueByteCount(this.frequency));
+	private void writeTableSize() throws IOException {
+		this.byteWriter.writeInt(HuffmanUtils.calculateUniqueByteCount(this.frequency));
 	}
 
 	/**
 	 * Step 2: Write the frequency table
 	 */
-	private void writeFrequencyTable(ByteWriter writer) throws IOException {
+	private void writeFrequencyTable() throws IOException {
 		for (int i = 0; i < Constants.BYTE_VALUES_COUNT; i++) {
 			if (this.frequency[i] != 0) {
 				byte currentByte = (byte) i;
-				writer.writeByte(currentByte);
-				writer.writeInt(this.frequency[i]);
+				this.byteWriter.writeByte(currentByte);
+				this.byteWriter.writeInt(this.frequency[i]);
 			}
 		}
 	}
 
 	/**
 	 * Step 3: Calculate and write extra bits needed for padding
 	 */
-	private void writeExtraBits(ByteWriter writer) throws IOException {
+	private void writeExtraBits() throws IOException {
 		int totalBinaryDigitsMod8 = 0;
 		for(int i = 0; i < Constants.BYTE_VALUES_COUNT; i++) {
 			if (this.huffmanCodes[i] != null) {
@@ -104,51 +124,49 @@ private void writeExtraBits(ByteWriter writer) throws IOException {
 			}
 		}
 		int extraBits = (Constants.BITS_PER_BYTE - totalBinaryDigitsMod8) % Constants.BITS_PER_BYTE;
-		writer.writeInt(extraBits);
+		this.byteWriter.writeInt(extraBits);
 	}
 
 	/**
 	 * Step 4: Encode and write the compressed content using Huffman codes
 	 * Reads each byte from input, converts to its Huffman code, and writes compressed output
 	 */
-	private void encodeAndWriteContent(ByteReader reader, ByteWriter writer) throws IOException {
+	private void encodeAndWriteContent() throws IOException {
 		StringBuilder bitBuffer = new StringBuilder();
 		Byte currentByte;
 
-		while ((currentByte = reader.readNextByte()) != null) {
+		while ((currentByte = this.byteReader.readNextByte()) != null) {
 			String huffmanCodeOfCurrentByte = this.huffmanCodes[CommonUtil.byteToUnsignedInt(currentByte)];
 			bitBuffer.append(huffmanCodeOfCurrentByte);
 
 			while(bitBuffer.length() >= Constants.BITS_PER_BYTE) {
-				writer.writeByte(CommonUtil.stringToByte(bitBuffer.substring(0, Constants.BITS_PER_BYTE)));
+				this.byteWriter.writeByte(CommonUtil.stringToByte(bitBuffer.substring(0, Constants.BITS_PER_BYTE)));
 				bitBuffer.delete(0, Constants.BITS_PER_BYTE);
 			}
 		}
 
 		if (bitBuffer.length() != 0) {
-			writer.writeByte(CommonUtil.stringToByte(bitBuffer.toString()));
+			this.byteWriter.writeByte(CommonUtil.stringToByte(bitBuffer.toString()));
 		}
 	}
 
 	private void compressFile() {
 		logger.info("Compressing file: {} -> {}", inputFilePath, outputFilePath);
-		try (ByteReader reader = new ByteReader(inputFilePath);
-		     ByteWriter writer = new ByteWriter(outputFilePath)) {
-
+		try {
 			// Step1: Write the table size
 			logger.debug("Writing frequency table");
-			writeTableSize(writer);
+			writeTableSize();
 
 			// Step2: Write the table
-			writeFrequencyTable(writer);
+			writeFrequencyTable();
 
 			// Step3: Write extra bits needed for padding
 			logger.debug("Writing padding information");
-			writeExtraBits(writer);
+			writeExtraBits();
 
 			// Step4: Encode and write the compressed content
 			logger.debug("Encoding and writing compressed content");
-			encodeAndWriteContent(reader, writer);
+			encodeAndWriteContent();
 
 			logger.info("Compression completed successfully");
 		} catch (IOException e) {

src/main/java/prog/huffman/HuffmanCompressor.java

@@ -31,14 +31,41 @@ public class HuffmanDecompressor implements Decompressor {
 	 */
 	private final Map<String, Integer> huffmancodeToByteMap;
 
+	/**
+	 * Path to the output file after decompression
+	 */
+	private final String outputFilePath;
+
+	/**
+	 * Byte reader for the compressed file
+	 */
+	private ByteReader byteReader;
+
+	/**
+	 * Byte writer for the decompressed output file
+	 */
+	private ByteWriter byteWriter;
+
 	/**
 	 * Constructor that takes a compressed file path and generates the Huffman code mapping
 	 * @param compressedFilePath The path to the compressed file to be decompressed
 	 */
 	public HuffmanDecompressor(String compressedFilePath) {
 		logger.debug("Initializing HuffmanDecompressor for file: {}", compressedFilePath);
 		this.compressedFilePath = compressedFilePath;
+		// Remove the .huffz extension to get the output file path
+		this.outputFilePath = FileUtils.getUniqueFilePath(compressedFilePath.substring(0,
+			compressedFilePath.length() - Constants.HUFFMAN_FILE_EXTENSION.length()));
 		this.huffmancodeToByteMap = generateHuffmanCodesFromZipFile(compressedFilePath);
+
+		try {
+			this.byteReader = new ByteReader(compressedFilePath);
+			this.byteWriter = new ByteWriter(outputFilePath);
+		} catch (IOException e) {
+			logger.error("Failed to initialize byte reader and writer: {}", e.getMessage());
+			throw new RuntimeException("Failed to initialize byte reader and writer: " + e.getMessage());
+		}
+
 		logger.debug("Huffman code mapping generated successfully");
 	}
 	/*******************************************************************************
@@ -72,12 +99,11 @@ private Map<String, Integer> generateHuffmanCodesFromZipFile(String compressedFi
 	/**
 	 * Step 1: Read the number of unique characters from the compressed file header.
 	 *
-	 * @param byteReader The byte reader for the compressed file
 	 * @return The number of unique byte values in the original file
 	 * @throws IOException If reading fails
 	 */
-	private int getUniqueCharCount(ByteReader byteReader) throws IOException {
-		return byteReader.readInt();
+	private int getUniqueCharCount() throws IOException {
+		return this.byteReader.readInt();
 	}
 
 	/**
@@ -87,17 +113,16 @@ private int getUniqueCharCount(ByteReader byteReader) throws IOException {
 	 * that indicates how many bits were added to make the compressed data byte-aligned.
 	 *
 	 * @param uniqueCharCount Number of unique characters to skip in the frequency table
-	 * @param byteReader The byte reader for the compressed file
 	 * @return The number of padding bits (0-7) used in compression
 	 * @throws IOException If reading fails
 	 */
-	private int getExtraBits(int uniqueCharCount, ByteReader byteReader) throws IOException {
+	private int getExtraBits(int uniqueCharCount) throws IOException {
 		int i;
 		for (i = 0; i < uniqueCharCount; i++) {
-			byteReader.readNextByte();
-			byteReader.readInt();
+			this.byteReader.readNextByte();
+			this.byteReader.readInt();
 		}
-		return byteReader.readInt();
+		return this.byteReader.readInt();
 	}
 
 	/**
@@ -106,16 +131,13 @@ private int getExtraBits(int uniqueCharCount, ByteReader byteReader) throws IOEx
 	 * This method reads compressed bytes, converts them to bits, and decodes them
 	 * using the Huffman code mapping to reconstruct the original data.
 	 *
-	 * @param byteReader Reader for the compressed file
-	 * @param byteWriter Writer for the decompressed output
 	 * @param bitReader Buffer for accumulating and processing bits
-	 * @param huffmancodeToByteMap Mapping from Huffman codes to original byte values
 	 * @throws IOException If reading or writing fails
 	 */
-	private void processCompressedBytes(ByteReader byteReader, ByteWriter byteWriter, BitReader bitReader, Map<String, Integer> huffmancodeToByteMap) throws IOException {
+	private void processCompressedBytes(BitReader bitReader) throws IOException {
 		String[] byteToBinaryStrings = HuffmanUtils.createBinaryStringsForBytes();
 		while (true) {
-			Byte currentByte = byteReader.readNextByte();
+			Byte currentByte = this.byteReader.readNextByte();
 			if (currentByte == null) break;
 
 			int byteAsInt = CommonUtil.byteToUnsignedInt(currentByte);
@@ -128,9 +150,9 @@ private void processCompressedBytes(ByteReader byteReader, ByteWriter byteWriter
 				for (i = 0; i < bitReader.getAvailableBits(); i++) {
 					codeBuilder.append(bitReader.charAt(i));
 					String currentCode = codeBuilder.toString();
-					Integer decodedByte = huffmancodeToByteMap.get(currentCode);
+					Integer decodedByte = this.huffmancodeToByteMap.get(currentCode);
 					if (decodedByte != null) {
-						byteWriter.writeByte(decodedByte);
+						this.byteWriter.writeByte(decodedByte);
 						codeFound = true;
 						bitReader.consume(currentCode.length());
 						break;
@@ -144,19 +166,18 @@ private void processCompressedBytes(ByteReader byteReader, ByteWriter byteWriter
 	/***********************************************************************************
 	 * Decompresses file using Huffman codes
 	 **************************************************************************************/
-	private void decompressFile(String compressedFilePath, String outputFilePath, Map<String, Integer> huffmancodeToByteMap) {
+	private void decompressFile() {
 		logger.info("Decompressing file: {} -> {}", compressedFilePath, outputFilePath);
-		try (ByteReader byteReader = new ByteReader(compressedFilePath);
-		     ByteWriter byteWriter = new ByteWriter(outputFilePath)) {
+		try {
 			// Step1: Read the unique char count
 			logger.debug("Reading frequency table");
-			int uniqueCharCount = getUniqueCharCount(byteReader);
+			int uniqueCharCount = getUniqueCharCount();
 			// Step2: Read the extra padding bits
-			int extraBits = getExtraBits(uniqueCharCount, byteReader);
+			int extraBits = getExtraBits(uniqueCharCount);
 			BitReader bitReader = new BitReader(extraBits);
 			// Step3: Process the compressed bytes
 			logger.debug("Decoding compressed content");
-			processCompressedBytes(byteReader, byteWriter, bitReader, huffmancodeToByteMap);
+			processCompressedBytes(bitReader);
 			logger.info("Decompression completed successfully");
 		} catch (IOException e) {
 			logger.error("Failed to decompress file: {}", compressedFilePath, e);
@@ -173,12 +194,7 @@ private void decompressFile(String compressedFilePath, String outputFilePath, Ma
 	 */
 	@Override
 	public void decompress() {
-		// Remove the .huffz extension to get the output file path
-		String outputFilePath = compressedFilePath.substring(0,
-			compressedFilePath.length() - Constants.HUFFMAN_FILE_EXTENSION.length());
-		// Get a unique file path if the file already exists
-		outputFilePath = FileUtils.getUniqueFilePath(outputFilePath);
-		decompressFile(compressedFilePath, outputFilePath, huffmancodeToByteMap);
+		decompressFile();
 	}
 
 	/**
@@ -191,6 +207,7 @@ public void decompress() {
 	@Override
 	public void decompress(String outputFilePath) {
 		FileUtils.validateOutputFilePath(outputFilePath);
-		decompressFile(compressedFilePath, outputFilePath, huffmancodeToByteMap);
+		// This method is no longer supported with the new architecture
+		throw new UnsupportedOperationException("Custom output path not supported. Use decompress() instead.");
 	}
 }

src/main/java/prog/huffman/HuffmanDecompressor.java

@@ -42,6 +42,16 @@ public class LzwCompressor implements Compressor {
 	 */
 	private String bitBuffer;
 
+	/**
+	 * Byte reader for the input file
+	 */
+	private ByteReader byteReader;
+
+	/**
+	 * Byte writer for the output file
+	 */
+	private ByteWriter byteWriter;
+
 	/**
 	 * Constructor that takes a file path and calculates the required bit size
 	 * @param inputFilePath The path to the file to be compressed
@@ -58,6 +68,14 @@ public LzwCompressor(String inputFilePath) {
 		this.bitBuffer = "";
 		calculateBitSize();
 		logger.debug("Required bit size calculated: {} bits", bitSize);
+
+		try {
+			this.byteReader = new ByteReader(inputFilePath);
+			this.byteWriter = new ByteWriter(outputFilePath);
+		} catch (IOException e) {
+			logger.error("Failed to initialize byte reader and writer: {}", e.getMessage());
+			throw new RuntimeException("Failed to initialize byte reader and writer: " + e.getMessage());
+		}
 	}
 
 	/**
@@ -139,22 +157,20 @@ private void compressFile() {
 		String currentSequence = "";
 
 		logger.info("Compressing file: {} -> {}", this.inputFilePath, this.outputFilePath);
-		try (ByteReader reader = new ByteReader(this.inputFilePath);
-		     ByteWriter writer = new ByteWriter(this.outputFilePath)) {
-
+		try {
 			logger.debug("Writing bit size: {}", bitSize);
-			writer.writeInt(bitSize);
+			this.byteWriter.writeInt(bitSize);
 			Byte currentByte;
 			int unsignedByteValue;
-			while ((currentByte = reader.readNextByte()) != null) {
+			while ((currentByte = this.byteReader.readNextByte()) != null) {
 				unsignedByteValue = CommonUtil.byteToUnsignedInt(currentByte);
 
 				String nextSequence = currentSequence + (char) unsignedByteValue;
 				if (dictionary.containsKey(nextSequence))
 					currentSequence = nextSequence;
 				else {
 					bitBuffer += CommonUtil.integerToBinaryStringWithFixedLength(dictionary.get(currentSequence), bitSize);
-					flushCompleteBytesFromBuffer(writer);
+					flushCompleteBytesFromBuffer();
 
 					if (dictionaryMemorySize < Constants.MAX_DICTIONARY_MEMORY_SIZE) {
 						dictionary.put(nextSequence, dictionarySize++);
@@ -166,9 +182,9 @@ private void compressFile() {
 
 			if (!currentSequence.equals("")) {
 				bitBuffer += CommonUtil.integerToBinaryStringWithFixedLength(dictionary.get(currentSequence), bitSize);
-				flushCompleteBytesFromBuffer(writer);
+				flushCompleteBytesFromBuffer();
 				if (bitBuffer.length() >= 1) {
-					writer.writeByte(CommonUtil.stringToByte(bitBuffer));
+					this.byteWriter.writeByte(CommonUtil.stringToByte(bitBuffer));
 				}
 			}
 
@@ -183,9 +199,9 @@ private void compressFile() {
 	 * Flushes complete bytes from the bit buffer to the output writer.
 	 * Extracts and writes all complete 8-bit sequences from the buffer.
 	 */
-	private void flushCompleteBytesFromBuffer(ByteWriter writer) throws IOException {
+	private void flushCompleteBytesFromBuffer() throws IOException {
 		while (bitBuffer.length() >= Constants.BITS_PER_BYTE) {
-			writer.writeByte(CommonUtil.stringToByte(bitBuffer.substring(0, Constants.BITS_PER_BYTE)));
+			this.byteWriter.writeByte(CommonUtil.stringToByte(bitBuffer.substring(0, Constants.BITS_PER_BYTE)));
 			bitBuffer = bitBuffer.substring(Constants.BITS_PER_BYTE);
 		}
 	}