test message

Author: ayonious

logs/file-compression.log

@@ -24,16 +24,6 @@ public interface Compressor {
      */
     void compress();
 
-    /**
-     * Compresses the file to a specific output path.
-     * Allows the caller to specify exactly where the compressed file should be saved.
-     *
-     * @param outputFilePath The absolute path where the compressed file will be saved
-     * @throws RuntimeException if compression fails
-     * @throws IllegalArgumentException if outputFilePath is null or invalid
-     */
-    void compress(String outputFilePath);
-
     /**
      * Cleans up any resources used by the compressor.
      * Should be called after compression is complete.

src/main/java/prog/compression/Compressor.java

@@ -22,14 +22,4 @@ public interface Decompressor {
      * @throws RuntimeException if decompression fails
      */
     void decompress();
-
-    /**
-     * Decompresses the file to a specific output path.
-     * Allows the caller to specify exactly where the decompressed file should be saved.
-     *
-     * @param outputFilePath The absolute path where the decompressed file will be saved
-     * @throws RuntimeException if decompression fails
-     * @throws IllegalArgumentException if outputFilePath is null or invalid
-     */
-    void decompress(String outputFilePath);
 }

src/main/java/prog/compression/Decompressor.java

@@ -21,6 +21,12 @@ public class HuffmanCompressor implements Compressor {
 	 */
 	private final String inputFilePath;
 
+	/**
+	 * Path to the output file that will be compressed
+	 * Example: "/home/user/document.txt.huffz"
+	 */
+	private final String outputFilePath;
+
 	/**
 	 * Array storing the frequency of each byte value (0-255) in the input file
 	 * Index represents the byte value, value represents the count
@@ -51,6 +57,7 @@ public class HuffmanCompressor implements Compressor {
 	public HuffmanCompressor(String inputFilePath) {
 		logger.debug("Initializing HuffmanCompressor for file: {}", inputFilePath);
 		this.inputFilePath = inputFilePath;
+		this.outputFilePath = inputFilePath + Constants.HUFFMAN_FILE_EXTENSION;
 		this.frequency = HuffmanUtils.calculateFrequencyOfBytesInFile(inputFilePath);
 
 		if (HuffmanUtils.isEmptyFile(frequency)) {
@@ -68,31 +75,31 @@ public HuffmanCompressor(String inputFilePath) {
 	/**
 	 * Step 1: Write the table size
 	 */
-	private void writeTableSize(ByteWriter writer, int[] frequency) throws IOException {
-		writer.writeInt(HuffmanUtils.calculateUniqueByteCount(frequency));
+	private void writeTableSize(ByteWriter writer) throws IOException {
+		writer.writeInt(HuffmanUtils.calculateUniqueByteCount(this.frequency));
 	}
 
 	/**
 	 * Step 2: Write the frequency table
 	 */
-	private void writeFrequencyTable(ByteWriter writer, int[] frequency) throws IOException {
+	private void writeFrequencyTable(ByteWriter writer) throws IOException {
 		for (int i = 0; i < Constants.BYTE_VALUES_COUNT; i++) {
-			if (frequency[i] != 0) {
+			if (this.frequency[i] != 0) {
 				byte currentByte = (byte) i;
 				writer.writeByte(currentByte);
-				writer.writeInt(frequency[i]);
+				writer.writeInt(this.frequency[i]);
 			}
 		}
 	}
 
 	/**
 	 * Step 3: Calculate and write extra bits needed for padding
 	 */
-	private void writeExtraBits(ByteWriter writer, int[] frequency, String[] huffmanCodes) throws IOException {
+	private void writeExtraBits(ByteWriter writer) throws IOException {
 		int totalBinaryDigitsMod8 = 0;
 		for(int i = 0; i < Constants.BYTE_VALUES_COUNT; i++) {
-			if (huffmanCodes[i] != null) {
-				totalBinaryDigitsMod8 += huffmanCodes[i].length() * frequency[i];
+			if (this.huffmanCodes[i] != null) {
+				totalBinaryDigitsMod8 += this.huffmanCodes[i].length() * this.frequency[i];
 				totalBinaryDigitsMod8 %= Constants.BITS_PER_BYTE;
 			}
 		}
@@ -104,12 +111,12 @@ private void writeExtraBits(ByteWriter writer, int[] frequency, String[] huffman
 	 * 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, String[] huffmanCodes) throws IOException {
+	private void encodeAndWriteContent(ByteReader reader, ByteWriter writer) throws IOException {
 		StringBuilder bitBuffer = new StringBuilder();
 		Byte currentByte;
 
 		while ((currentByte = reader.readNextByte()) != null) {
-			String huffmanCodeOfCurrentByte = huffmanCodes[CommonUtil.byteToUnsignedInt(currentByte)];
+			String huffmanCodeOfCurrentByte = this.huffmanCodes[CommonUtil.byteToUnsignedInt(currentByte)];
 			bitBuffer.append(huffmanCodeOfCurrentByte);
 
 			while(bitBuffer.length() >= Constants.BITS_PER_BYTE) {
@@ -123,25 +130,25 @@ private void encodeAndWriteContent(ByteReader reader, ByteWriter writer, String[
 		}
 	}
 
-	private void compressFile(String inputFilePath, String outputFilePath, int[] frequency, String[] huffmanCodes) {
+	private void compressFile() {
 		logger.info("Compressing file: {} -> {}", inputFilePath, outputFilePath);
 		try (ByteReader reader = new ByteReader(inputFilePath);
 		     ByteWriter writer = new ByteWriter(outputFilePath)) {
 
 			// Step1: Write the table size
 			logger.debug("Writing frequency table");
-			writeTableSize(writer, frequency);
+			writeTableSize(writer);
 
 			// Step2: Write the table
-			writeFrequencyTable(writer, frequency);
+			writeFrequencyTable(writer);
 
 			// Step3: Write extra bits needed for padding
 			logger.debug("Writing padding information");
-			writeExtraBits(writer, frequency, huffmanCodes);
+			writeExtraBits(writer);
 
 			// Step4: Encode and write the compressed content
 			logger.debug("Encoding and writing compressed content");
-			encodeAndWriteContent(reader, writer, huffmanCodes);
+			encodeAndWriteContent(reader, writer);
 
 			logger.info("Compression completed successfully");
 		} catch (IOException e) {
@@ -158,21 +165,7 @@ private void compressFile(String inputFilePath, String outputFilePath, int[] fre
 	 */
 	@Override
 	public void compress() {
-		String outputFilePath = inputFilePath + Constants.HUFFMAN_FILE_EXTENSION;
-		compressFile(inputFilePath, outputFilePath, frequency, huffmanCodes);
-	}
-
-	/**
-	 * Compresses the file to a specific output path
-	 *
-	 * @param outputFilePath The path where the compressed file will be saved
-	 * @throws RuntimeException if compression fails
-	 * @throws IllegalArgumentException if outputFilePath is null or invalid
-	 */
-	@Override
-	public void compress(String outputFilePath) {
-		CommonUtil.validateOutputFilePath(outputFilePath);
-		compressFile(inputFilePath, outputFilePath, frequency, huffmanCodes);
+		compressFile();
 	}
 
 	/**

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

@@ -8,6 +8,8 @@
 import prog.util.ByteWriter;
 import prog.util.CommonUtil;
 import prog.util.Constants;
+import prog.util.FileUtils;
+
 import java.io.IOException;
 import java.util.Map;
 
@@ -20,6 +22,13 @@ public class LzwCompressor implements Compressor {
 	 */
 	private final String inputFilePath;
 
+
+	/**
+	 * Path to the output file that will be compressed
+	 * Example: "/home/user/document.txt.LmZWp"
+	 */
+	private final String outputFilePath;
+
 	/**
 	 * Number of bits required to encode dictionary entries
 	 * Calculated based on the final dictionary size after a preliminary scan
@@ -38,12 +47,13 @@ public class LzwCompressor implements Compressor {
 	 * @param inputFilePath The path to the file to be compressed
 	 */
 	public LzwCompressor(String inputFilePath) {
+		this.inputFilePath = inputFilePath;
+		this.outputFilePath = inputFilePath + Constants.LZW_FILE_EXTENSION;
 		logger.debug("Initializing LzwCompressor for file: {}", inputFilePath);
-		if (CommonUtil.isEmptyFile(inputFilePath)) {
+		if (FileUtils.isEmptyFile(inputFilePath)) {
 			logger.error("Attempted to compress empty file: {}", inputFilePath);
 			throw new IllegalArgumentException("Cannot compress empty file: " + inputFilePath);
 		}
-		this.inputFilePath = inputFilePath;
 		this.bitSize = 0;
 		this.bitBuffer = "";
 		calculateBitSize();
@@ -119,19 +129,18 @@ private void calculateBitSize() {
 	 * Output: codes for ['A', 'B', 256, 'A']
 	 * </pre>
 	 *
-	 * @param outputFilePath The path where the compressed file will be saved
 	 * @throws RuntimeException if an IO error occurs during compression
 	 */
-	private void compressFile(String outputFilePath) {
+	private void compressFile() {
 		Map<String, Integer> dictionary = LzwUtils.initializeCompressionDictionary();
 		int dictionarySize = Constants.BYTE_VALUES_COUNT;
 		bitBuffer = "";
 		int dictionaryMemorySize = Constants.BYTE_VALUES_COUNT;
 		String currentSequence = "";
 
-		logger.info("Compressing file: {} -> {}", inputFilePath, outputFilePath);
-		try (ByteReader reader = new ByteReader(inputFilePath);
-		     ByteWriter writer = new ByteWriter(outputFilePath)) {
+		logger.info("Compressing file: {} -> {}", this.inputFilePath, this.outputFilePath);
+		try (ByteReader reader = new ByteReader(this.inputFilePath);
+		     ByteWriter writer = new ByteWriter(this.outputFilePath)) {
 
 			logger.debug("Writing bit size: {}", bitSize);
 			writer.writeInt(bitSize);
@@ -189,20 +198,6 @@ private void flushCompleteBytesFromBuffer(ByteWriter writer) throws IOException
 	 */
 	@Override
 	public void compress() {
-		String outputFilePath = inputFilePath + Constants.LZW_FILE_EXTENSION;
-		compressFile(outputFilePath);
-	}
-
-	/**
-	 * Compresses the file to a specific output path
-	 *
-	 * @param outputFilePath The path where the compressed file will be saved
-	 * @throws RuntimeException if compression fails
-	 * @throws IllegalArgumentException if outputFilePath is null or invalid
-	 */
-	@Override
-	public void compress(String outputFilePath) {
-		CommonUtil.validateOutputFilePath(outputFilePath);
-		compressFile(outputFilePath);
+		compressFile();
 	}
 }

src/main/java/prog/lzw/LzwCompressor.java

@@ -21,6 +21,12 @@ public class LzwDecompressor implements Decompressor {
 	 */
 	private final String compressedFilePath;
 
+	/**
+	 * Path to the output file that will be decompressed
+	 * Example: "/home/user/document.txt"
+	 */
+	private final String outputFilePath;
+
 	/**
 	 * Number of bits used to encode dictionary entries
 	 * Read from the compressed file header
@@ -47,6 +53,8 @@ public class LzwDecompressor implements Decompressor {
 	public LzwDecompressor(String compressedFilePath) {
 		logger.debug("Initializing LzwDecompressor for file: {}", compressedFilePath);
 		this.compressedFilePath = compressedFilePath;
+		this.outputFilePath = FileUtils.getUniqueFilePath(compressedFilePath.substring(0,
+			compressedFilePath.length() - Constants.LZW_FILE_EXTENSION.length()));
 		this.bitSize = 0;
 		this.bitBuffer = "";
 		this.byteToBinaryLookup = CommonUtil.createByteToBinaryLookupTable();
@@ -109,10 +117,9 @@ private void writeString(ByteWriter writer, String text) throws IOException {
 	 * added is the one we're currently processing. In this case, the sequence is:
 	 * previous sequence + first character of previous sequence.</p>
 	 *
-	 * @param outputFilePath The path where the decompressed file will be saved
 	 * @throws RuntimeException if an IO error occurs during decompression
 	 */
-	private void decompressFile(String outputFilePath) {
+	private void decompressFile() {
 		logger.info("Decompressing file: {} -> {}", compressedFilePath, outputFilePath);
 		int code;
 		int dictionarySize = Constants.BYTE_VALUES_COUNT;
@@ -191,23 +198,6 @@ private void decompressFile(String outputFilePath) {
 	 */
 	@Override
 	public void decompress() {
-		String outputFilePath = compressedFilePath.substring(0,
-			compressedFilePath.length() - Constants.LZW_FILE_EXTENSION.length());
-		// Get a unique file path if the file already exists
-		outputFilePath = FileUtils.getUniqueFilePath(outputFilePath);
-		decompressFile(outputFilePath);
-	}
-
-	/**
-	 * 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(outputFilePath);
+		decompressFile();
 	}
 }

src/main/java/prog/lzw/LzwDecompressor.java

@@ -220,28 +220,4 @@ public static String[] createByteToBinaryLookupTable() {
         }
         return lookupTable;
     }
-
-    /**
-     * Checks if a file is empty by checking its length.
-     *
-     * @deprecated Use {@link FileUtils#isEmptyFile(String)} instead.
-     * @param filePath Path to the file to check
-     * @return true if file is empty (length = 0), false otherwise
-     */
-    @Deprecated
-    public static boolean isEmptyFile(String filePath) {
-        return FileUtils.isEmptyFile(filePath);
-    }
-
-    /**
-     * Validates that an output file path is not null or empty.
-     *
-     * @deprecated Use {@link FileUtils#validateOutputFilePath(String)} instead.
-     * @param outputFilePath The output file path to validate
-     * @throws IllegalArgumentException if outputFilePath is null or empty/whitespace
-     */
-    @Deprecated
-    public static void validateOutputFilePath(String outputFilePath) {
-        FileUtils.validateOutputFilePath(outputFilePath);
-    }
 }