Homework 3 - [LZW]

Zipper/Zipper.Cli/FileZipper.cs

@@ -0,0 +1,122 @@
+namespace Zipper.Cli;
+
+using System.Buffers;
+using System.Diagnostics;
+
+/// <summary>
+/// Provides methods and properties used to compress and decompress files.
+/// </summary>
+internal class FileZipper : IDisposable
+{
+    private const int BufferSize = 512 * 1024;
+    private static readonly ArrayPool<byte> BufferPool = ArrayPool<byte>.Create();
+
+    private readonly string? outputFileName;
+    private readonly string? outputFileNameTempA;
+    private readonly string? outputFileNameTempB;
+
+    private readonly Stream readFrom;
+    private readonly Stream writeTo;
+    private readonly Stream? writeToAlt;
+    private readonly long inputFileSize;
+    private readonly byte[] buffer;
+
+    private long bytesReadFromInput;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FileZipper"/> class.
+    /// </summary>
+    /// <param name="mode">Mode to use.</param>
+    /// <param name="inputFilePath">File to read data from.</param>
+    /// <param name="outputFilePath">File to write compressed/decompressed data to.</param>
+    public FileZipper(ZipperMode mode, string inputFilePath, string outputFilePath)
+    {
+        inputFileSize = new FileInfo(inputFilePath).Length;
+
+        var inputFile = File.OpenRead(inputFilePath);
+
+        if (mode == ZipperMode.Compress)
+        {
+            outputFileName = outputFilePath;
+            outputFileNameTempA = Path.GetTempFileName();
+            outputFileNameTempB = Path.GetTempFileName();
+
+            var outputFileA = File.Create(outputFileNameTempA);
+            var outputFileB = File.Create(outputFileNameTempB);
+
+            readFrom = inputFile;
+            writeTo = new ZipperStream(outputFileA, ZipperStream.MaxBlockSize, mode);
+            writeToAlt = new ZipperStream(outputFileB, ZipperStream.MaxBlockSize, mode, useBwt: true);
+        }
+        else
+        {
+            var outputFile = File.Create(outputFilePath);
+            readFrom = new ZipperStream(inputFile, ZipperStream.MaxBlockSize, mode);
+            writeTo = outputFile;
+        }
+
+        bytesReadFromInput = 0;
+        buffer = BufferPool.Rent(BufferSize);
+
+        EndOfFile = false;
+    }
+
+    /// <summary>
+    /// Gets progress as value between 0 and 1.
+    /// </summary>
+    public float Progress => (float)bytesReadFromInput / inputFileSize;
+
+    /// <summary>
+    /// Gets a value indicating whether end of file was reached.
+    /// </summary>
+    public bool EndOfFile { get; private set; }
+
+    /// <summary>
+    /// Compresses or decompresses part of input file.
+    /// </summary>
+    public void ReadAndWriteSingleBuffer()
+    {
+        int bytesRead = readFrom.Read(buffer, 0, BufferSize);
+
+        if (bytesRead == 0)
+        {
+            EndOfFile = true;
+            return;
+        }
+
+        bytesReadFromInput += bytesRead;
+
+        writeTo.Write(buffer, 0, bytesRead);
+        writeToAlt?.Write(buffer, 0, bytesRead);
+    }
+
+    /// <summary>
+    /// Disposes all used files.
+    /// </summary>
+    public void Dispose()
+    {
+        BufferPool.Return(buffer);
+
+        readFrom.Dispose();
+        writeTo.Dispose();
+        writeToAlt?.Dispose();
+
+        if (outputFileName != null)
+        {
+            Debug.Assert(outputFileNameTempA != null, $"{nameof(outputFileNameTempA)} is null");
+            Debug.Assert(outputFileNameTempB != null, $"{nameof(outputFileNameTempB)} is null");
+
+            var tempLengthA = new FileInfo(outputFileNameTempA).Length;
+            var tempLengthB = new FileInfo(outputFileNameTempB).Length;
+
+            if (tempLengthA < tempLengthB)
+            {
+                File.Move(outputFileNameTempA, outputFileName, true);
+            }
+            else
+            {
+                File.Move(outputFileNameTempB, outputFileName, true);
+            }
+        }
+    }
+}

Zipper/Zipper.Cli/Program.cs

@@ -0,0 +1,179 @@
+using System.Diagnostics;
+using Zipper;
+using Zipper.Cli;
+
+const string helpMessage =
+"""
+Zipper - console tool for compressing and decompressing files
+
+Usage: dotnet run -- <file> [options]
+Options:
+    -h -? --help    | Print this help message
+    ------------------------------------------------
+    -c --compress   | Compress specified file
+    ------------------------------------------------
+    -u --uncompress | Decompress
+    -d --decompress | specified file
+    ------------------------------------------------
+    -f --force      | Overwrite files without asking
+
+File path should be the first argument (unless --help specified)
+Options can be specified in any order
+Only either '--compress' or '--decompress' can be used at the same time
+""";
+
+args = [.. args.Select(x => x.Trim())];
+
+if (args.Length == 0 || (args.Length == 1 && args[0] is "-h" or "--help" or "-?"))
+{
+    Console.WriteLine(helpMessage);
+
+    return 0;
+}
+
+string filePath = args[0];
+bool force = false;
+ZipperMode? mode = null;
+
+foreach (var arg in args.Skip(1))
+{
+    switch (arg)
+    {
+        case "-u" or "-d" or "--uncompress" or "--decompress":
+            if (mode != null)
+            {
+                Console.Error.WriteLine("Error: '--compress' or '--decompress' option can only be specified once");
+                return 1;
+            }
+
+            mode = ZipperMode.Decompress;
+            break;
+
+        case "-c" or "--compress":
+            if (mode != null)
+            {
+                Console.Error.WriteLine("Error: '--compress' or '--decompress' option can only be specified once");
+                return 1;
+            }
+
+            mode = ZipperMode.Compress;
+            break;
+
+        case "-f" or "--force":
+            force = true;
+            break;
+
+        default:
+            Console.Error.WriteLine("Error: unknown argument");
+            return 1;
+    }
+}
+
+if (mode == null)
+{
+    Console.Error.WriteLine("Error: neither '--compress' nor '--decompress' were specified");
+    return 1;
+}
+
+if (!File.Exists(filePath))
+{
+    Console.Error.WriteLine($"Error: file '{filePath}' does not exist");
+    return 1;
+}
+
+const string zippedExtension = ".zipped";
+string? newFilePath = null;
+if (mode == ZipperMode.Compress)
+{
+    newFilePath = $"{filePath}{zippedExtension}";
+}
+else
+{
+    if (!filePath.EndsWith(zippedExtension))
+    {
+        Console.Error.WriteLine($"Error: extension of the specified file is not {zippedExtension}");
+        return 1;
+    }
+
+    newFilePath = filePath[..^zippedExtension.Length];
+}
+
+if (!force && File.Exists(newFilePath))
+{
+    Console.Write($"File '{newFilePath}' already exists, overwrite? (y/n): ");
+    if (Console.ReadLine()?.Trim() != "y")
+    {
+        Console.WriteLine("Cancelled");
+        return 0;
+    }
+}
+
+const string hideCursorEscape = "\e[?25l";
+const string showCursorEscape = "\e[?25h";
+const string moveToLeftEscape = "\e[0G";
+const string clearLineEscape = "\e[2K";
+const string waitingSymblols = @"|/-\";
+
+Console.Write(hideCursorEscape);
+
+using (var fileZipper = new FileZipper(mode.Value, filePath, newFilePath))
+{
+    var stopwatch = Stopwatch.StartNew();
+    var lastLoggedTime = stopwatch.Elapsed;
+    int step = 0;
+    while (!fileZipper.EndOfFile)
+    {
+        fileZipper.ReadAndWriteSingleBuffer();
+
+        if (stopwatch.Elapsed - lastLoggedTime > TimeSpan.FromMilliseconds(4))
+        {
+            Console.Write(moveToLeftEscape);
+            RenderProgress(fileZipper.Progress, stopwatch.Elapsed, step, waitingSymblols);
+            lastLoggedTime = stopwatch.Elapsed;
+        }
+
+        step += 1;
+    }
+}
+
+Console.Write(clearLineEscape);
+Console.Write(moveToLeftEscape);
+Console.Write(showCursorEscape);
+
+if (mode == ZipperMode.Compress)
+{
+    var inputFileSize = new FileInfo(filePath).Length;
+    var outputFileSize = new FileInfo(newFilePath).Length;
+    var compressionRate = (float)inputFileSize / outputFileSize;
+
+    Console.WriteLine($"Compression rate: {compressionRate}");
+}
+
+return 0;
+
+static void RenderProgress(float progress, TimeSpan time, int step, string stepString)
+{
+    Console.Write($" {stepString[step % stepString.Length]} ");
+    Console.Write("[");
+
+    for (int i = 0; i <= 100; i++)
+    {
+        Console.Write(progress >= i / 100f ? '=' : ' ');
+    }
+
+    Console.Write("]");
+    Console.Write($" {progress * 100,5:0.0} %");
+
+    if (time.TotalMinutes < 1)
+    {
+        Console.Write($" {time.Seconds} s");
+    }
+    else if (time.TotalHours < 1)
+    {
+        Console.Write($" {time.Minutes} m {time.Seconds:00} s");
+    }
+    else
+    {
+        Console.Write($" {time.Hours} h {time.Minutes:00} m {time.Seconds:00} s");
+    }
+}

Zipper/Zipper.Cli/Zipper.Cli.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../Zipper/Zipper.csproj" />
+  </ItemGroup>
+
+</Project>