chore: Refactor

Author: ayonious

.gitignore

@@ -22,3 +22,5 @@ target/
 *.war
 *.ear
 *.class
+
+logs/file-compression.log

README.md

@@ -124,7 +124,7 @@ mvn exec:java
 ### Using JAR directly
 After building with Maven, you can run the JAR:
 ```bash
-java -jar target/file-compression-1.0-SNAPSHOT-jar-with-dependencies.jar
+java -jar target/file-compression-2.0-SNAPSHOT-jar-with-dependencies.jar
 ```
 
 ![Outlook](/git_resource/outlook.png?raw=true "File Compression GUI")

logs/file-compression.log

@@ -6,7 +6,7 @@
 
     <groupId>prog</groupId>
     <artifactId>file-compression</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>2.0-SNAPSHOT</version>
 
     <properties>
         <maven.compiler.source>21</maven.compiler.source>

pom.xml

@@ -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,24 +194,6 @@ 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);
-	}
-
-	/**
-	 * Decompresses the file to a specific output path
-	 *
-	 * @param outputFilePath The path where the decompressed file will be saved
-	 * @throws RuntimeException if decompression fails
-	 * @throws IllegalArgumentException if outputFilePath is null or invalid
-	 */
-	@Override
-	public void decompress(String outputFilePath) {
-		FileUtils.validateOutputFilePath(outputFilePath);
-		decompressFile(compressedFilePath, outputFilePath, huffmancodeToByteMap);
+		decompressFile();
 	}
 }

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

@@ -198,7 +198,6 @@ public static String[] generateHuffmanCodes(HuffmanNode node) {
      * }</pre>
      *
      * @return An array of Constants.BYTE_VALUES_COUNT strings where index i contains the binary representation of byte value i
-     * @since 1.0
      */
     public static String[] createBinaryStringsForBytes() {
         String[] byteToBinaryStrings = new String[Constants.BYTE_VALUES_COUNT];