Merge branch 'feature/2.2.0-2025q1'

ExtSort/Code/Extensions/StreamExtensions.cs

@@ -5,8 +5,9 @@ internal static class StreamExtensions
         public static void SkipPreamble(this StreamWriter writer) 
         {
             var tmp = writer.AutoFlush;
-            writer.AutoFlush = false;
-            writer.BaseStream.Position = 0;
+            writer.AutoFlush = true;
+            if (writer.BaseStream.Position > 0)
+                writer.BaseStream.Position = 0;
             writer.AutoFlush = tmp;
         }
     }

ExtSort/Code/Streams/StreamReaderWrapper.cs

@@ -3,8 +3,13 @@
 
 namespace ExtSort.Code.Streams
 {
+    /// <summary>
+    /// Wrapper around the <see cref="StreamReader"/> to allow read
+    /// lines as the Span or as the Memory of type char
+    /// </summary>
     public class StreamReaderWrapper : TextReader
     {
+        #region StreamReader Implementation
         // Using a 1K byte buffer and a 4K FileStream buffer works out pretty well
         // perf-wise.  On even a 40 MB text file, any perf loss by using a 4K
         // buffer is negated by the win of allocating a smaller byte[], which
@@ -594,34 +599,80 @@ private void ThrowIfDisposed()
             void ThrowObjectDisposedException() => throw new ObjectDisposedException(GetType().Name);
         }
 
-        public Memory<char> ReadLineAsMemory()
+        private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
         {
-            ThrowIfDisposed();
+            ValidateArgs(path, encoding);
 
-            if (_charPos == _charLen)
+            if (options is null)
             {
-                if (ReadBuffer() == 0)
+                throw new ArgumentNullException(nameof(options));
+            }
+            if ((options.Access & FileAccess.Read) == 0)
+            {
+                throw new ArgumentException(nameof(options));
+            }
+
+            return new FileStream(path, options);
+        }
+
+        private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, int bufferSize)
+        {
+            ValidateArgs(path, encoding);
+            if (bufferSize <= 0)
+                throw new ArgumentOutOfRangeException(nameof(bufferSize));
+
+            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize);
+        }
+
+        private static void ValidateArgs(string path, Encoding encoding)
+        {
+            if (path == null)
+                throw new ArgumentNullException(nameof(path));
+            if (encoding == null)
+                throw new ArgumentNullException(nameof(encoding));
+            if (path.Length == 0)
+                throw new ArgumentException();
+        }
+
+        public bool EndOfStream
+        {
+            get
+            {
+                ThrowIfDisposed();
+
+                if (_charPos < _charLen)
                 {
+                    return false;
+                }
+
+                // This may block on pipes!
+                int numRead = ReadBuffer();
+                return numRead == 0;
+            }
+        }
+
+        #endregion
+
+        public Memory<char> ReadLineAsMemory() {
+            ThrowIfDisposed();
+
+            if (_charPos == _charLen) {
+                if (ReadBuffer() == 0) {
                     return null;
                 }
             }
 
-            do
-            {
+            do {
                 int i = _charPos;
-                do
-                {
+                do {
                     char ch = _charBuffer[i];
                     // Note the following common line feed chars:
                     // \n - UNIX   \r\n - DOS   \r - Mac
-                    if (ch == '\r' || ch == '\n')
-                    {
+                    if (ch == '\r' || ch == '\n') {
                         var result = _charBuffer.AsMemory().Slice(_charPos, i - _charPos);
                         _charPos = i + 1;
-                        if (ch == '\r' && (_charPos < _charLen || ReadBuffer() > 0))
-                        {
-                            if (_charBuffer[_charPos] == '\n')
-                            {
+                        if (ch == '\r' && (_charPos < _charLen || ReadBuffer() > 0)) {
+                            if (_charBuffer[_charPos] == '\n') {
                                 _charPos++;
                             }
                         }
@@ -636,34 +687,26 @@ public Memory<char> ReadLineAsMemory()
             return _charBuffer.AsMemory();
         }
 
-        public Span<char> ReadLineAsSpan()
-        {
+        public Span<char> ReadLineAsSpan() {
             ThrowIfDisposed();
 
-            if (_charPos == _charLen)
-            {
-                if (ReadBuffer() == 0)
-                {
+            if (_charPos == _charLen) {
+                if (ReadBuffer() == 0) {
                     return null;
                 }
             }
 
-            do
-            {
+            do {
                 int i = _charPos;
-                do
-                {
+                do {
                     char ch = _charBuffer[i];
                     // Note the following common line feed chars:
                     // \n - UNIX   \r\n - DOS   \r - Mac
-                    if (ch == '\r' || ch == '\n')
-                    {
+                    if (ch == '\r' || ch == '\n') {
                         var result = _charBuffer.AsSpan().Slice(_charPos, i - _charPos);
                         _charPos = i + 1;
-                        if (ch == '\r' && (_charPos < _charLen || ReadBuffer() > 0))
-                        {
-                            if (_charBuffer[_charPos] == '\n')
-                            {
+                        if (ch == '\r' && (_charPos < _charLen || ReadBuffer() > 0)) {
+                            if (_charBuffer[_charPos] == '\n') {
                                 _charPos++;
                             }
                         }
@@ -677,58 +720,5 @@ public Span<char> ReadLineAsSpan()
             } while (ReadBuffer() > 0);
             return _charBuffer.AsSpan();
         }
-
-        private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
-        {
-            ValidateArgs(path, encoding);
-
-            if (options is null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-            if ((options.Access & FileAccess.Read) == 0)
-            {
-                throw new ArgumentException(nameof(options));
-            }
-
-            return new FileStream(path, options);
-        }
-
-        private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, int bufferSize)
-        {
-            ValidateArgs(path, encoding);
-            if (bufferSize <= 0)
-                throw new ArgumentOutOfRangeException(nameof(bufferSize));
-
-            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, DefaultFileStreamBufferSize);
-        }
-
-        private static void ValidateArgs(string path, Encoding encoding)
-        {
-            if (path == null)
-                throw new ArgumentNullException(nameof(path));
-            if (encoding == null)
-                throw new ArgumentNullException(nameof(encoding));
-            if (path.Length == 0)
-                throw new ArgumentException();
-        }
-
-        public bool EndOfStream
-        {
-            get
-            {
-                ThrowIfDisposed();
-
-                if (_charPos < _charLen)
-                {
-                    return false;
-                }
-
-                // This may block on pipes!
-                int numRead = ReadBuffer();
-                return numRead == 0;
-            }
-        }
-
     }
 }

ExtSort/Models/Binders/EvaluatorBinder.cs

@@ -0,0 +1,32 @@
+using ExtSort.Services.Factories;
+
+using System.CommandLine.Parsing;
+
+namespace ExtSort.Models.Binders
+{
+    internal record EvaluatorBinder()
+    {
+        public EvaluatorBinder(ParseResult parser) : this()
+        {
+            var args = ArgumentFactory.EvaluatorArguments.Value;
+
+            if (!int.TryParse(parser.GetValueForArgument(args[nameof(DiskLatencyMs)])?.ToString(), out var diskLatencyMs))
+                throw new InvalidCastException("The size of RAM available is in incorrect format.");
+            if (!int.TryParse(parser.GetValueForArgument(args[nameof(DiskRandomReadSpeedMbs)])?.ToString(), out var diskRandomReadSpeedMbs))
+                throw new InvalidCastException("The size of RAM available is in incorrect format.");
+
+            FileSizeMb = (int)parser.GetValueForArgument(args[nameof(FileSizeMb)]);
+            RamAvailableMb = (int)parser.GetValueForArgument(args[nameof(RamAvailableMb)]);
+            NumberOfFiles = (int)parser.GetValueForArgument(args[nameof(NumberOfFiles)]);
+
+            DiskLatencyMs = diskLatencyMs;
+            DiskRandomReadSpeedMbs = diskRandomReadSpeedMbs;
+        }
+
+        public int FileSizeMb { get; init; }
+        public int RamAvailableMb { get; init; }
+        public int NumberOfFiles { get; init; }
+        public int DiskLatencyMs { get; init; }
+        public int DiskRandomReadSpeedMbs { get; init; }
+    }
+}

ExtSort/Models/Binders/GeneratorBinder.cs

@@ -0,0 +1,22 @@
+using ExtSort.Services.Factories;
+using System.CommandLine.Parsing;
+
+namespace ExtSort.Models.Binders 
+{
+    internal record GeneratorBinder
+    {
+        public GeneratorBinder(ParseResult parser) 
+        {
+            var args = ArgumentFactory.GeneratorArguments.Value;
+
+            if (!long.TryParse(parser.GetValueForArgument(args[nameof(TargetFileSizeKb)])?.ToString(), out var fileSizeKb))
+                throw new InvalidCastException("The length of the output file is in incorrect format.");
+
+            TargetFileSizeKb = fileSizeKb;
+            TargetFileName = (string)parser.GetValueForArgument(args[nameof(TargetFileName)]);
+        }
+
+        public string TargetFileName { get; init; }
+        public long TargetFileSizeKb { get; init; }
+    }
+}

ExtSort/Models/Binders/SorterBinder.cs

@@ -0,0 +1,23 @@
+using ExtSort.Code.Enums;
+using ExtSort.Services.Factories;
+
+using System.CommandLine.Parsing;
+
+namespace ExtSort.Models.Binders 
+{
+    internal record SorterBinder
+    {
+        public SorterBinder(ParseResult parser) 
+        {
+            var args = ArgumentFactory.SorterArguments.Value;
+
+            TargetFileName = (string)parser.GetValueForArgument(args[nameof(TargetFileName)]);
+            SourceFileName = (string)parser.GetValueForArgument(args[nameof(SourceFileName)]);
+            Mode = (SortMode)parser.GetValueForArgument(args[nameof(Mode)]);
+        }
+
+        public string TargetFileName { get; init; }
+        public string SourceFileName { get; init; }
+        public SortMode Mode { get; init; }
+    }
+}

ExtSort/Models/Settings/EvaluatorSettings.cs

@@ -0,0 +1,31 @@
+using ExtSort.Models.Binders;
+
+using System.Text;
+
+namespace ExtSort.Models.Settings 
+{
+    internal record EvaluatorSettings : EvaluatorBinder 
+    {
+        public EvaluatorSettings(EvaluatorBinder settings) : base(settings) 
+        {
+
+        }
+
+        public bool Validate(out StringBuilder errors) 
+        {
+            errors = new StringBuilder();
+            if (NumberOfFiles < 1)
+                errors.AppendLine("The number of files must be equal or greater than 1");
+            if (RamAvailableMb <= 0)
+                errors.AppendLine("The RAM available must be greater than 0");
+            if (FileSizeMb <= 0)
+                errors.AppendLine("The file size must be greater than 0");
+            if (DiskLatencyMs < 0)
+                errors.AppendLine("The disk latency cannot be negative");
+            if (DiskRandomReadSpeedMbs <= 0)
+                errors.AppendLine("The disk random access speed must be greather than 0");
+
+            return errors.Length == 0;
+        }
+    }
+}

ExtSort/Models/Settings/FormatSettings.cs

@@ -7,7 +7,7 @@ public record FormatSettings
         public string EncodingName { get; init; } = "utf-8";
         public bool UsePreamble { get; init; } = true;
         public string ColumnSeparator { get; init; } = ".";
-        public char NewLineDelimiter { get; init; } = '\n';
+        public char? NewLineDelimiter { get; init; } = '\n';
 
         public bool Validate(out StringBuilder errors) 
         {
@@ -16,6 +16,10 @@ public bool Validate(out StringBuilder errors)
                 errors.AppendLine("The encoding name is not specified");
             if (string.IsNullOrEmpty(ColumnSeparator))
                 errors.AppendLine("The column separator string is not specified");
+            if (NewLineDelimiter == null)
+                errors.AppendLine("The new line delimiter character is not specified");
+            if (NewLineDelimiter == char.MinValue)
+                errors.AppendLine("The new line delimiter must differs from the NULL symbol");
             if (!Encoding.GetEncodings().Any(arg => arg.Name == EncodingName))
                 errors.AppendLine($"The provided encoding {EncodingName} does not exist");
 

ExtSort/Properties/launchSettings.json

@@ -14,7 +14,7 @@
     },
     "EvaluateDebugProfile": {
       "commandName": "Project",
-      "commandLineArgs": "eval"
+      "commandLineArgs": "eval 1024 4096 64 100 10"
     },
     "HelpProfile": {
       "commandName": "Project",