more changes

Author: Hirogen

src/ColumnizerLib/ILogLine.cs

@@ -38,14 +38,25 @@ public interface ILogLine : ITextValue
 /// was replaced to better align with these performance and semantic requirements.
 /// </para>
 /// </remarks>
-public readonly struct LogLine (string fullLine, int lineNumber) : ILogLine
+public class LogLine (string fullLine, int lineNumber) : ILogLineMemory
 {
-    public string FullLine { get; } = fullLine;
+    private readonly ReadOnlyMemory<char> _lineMemory;
+    private string _cachedString;
+
+    public LogLine (ReadOnlyMemory<char> lineMemory, int lineNumber) : this(lineMemory.ToString(), lineNumber)
+    {
+        FullLineMemory = lineMemory;
+        LineNumber = lineNumber;
+    }
+
+    public string FullLine => _cachedString ??= _lineMemory.ToString();
 
     public int LineNumber { get; } = lineNumber;
 
     public string Text => FullLine;
 
+    public ReadOnlyMemory<char> FullLineMemory { get; }
+
     public override bool Equals (object obj)
     {
         return obj is LogLine other &&

src/ColumnizerLib/ILogLineMemory.cs

@@ -0,0 +1,6 @@
+namespace ColumnizerLib;
+
+public interface ILogLineMemory : ILogLine
+{
+    ReadOnlyMemory<char> FullLineMemory { get; }
+}

src/LogExpert.Core/Classes/Log/LogBuffer.cs

@@ -14,6 +14,8 @@ public class LogBuffer
     private readonly IList<long> _filePositions = []; // file position for every line
 #endif
 
+    private readonly List<ILogLineMemory> _lineList = new();
+
     private readonly IList<ILogLine> _logLines = [];
     private int MAX_LINES = 500;
     private long _size;

src/LogExpert.Core/Classes/Log/LogStreamReaderBase.cs

@@ -59,4 +59,4 @@ public void Dispose ()
     public abstract string ReadLine ();
 
     #endregion
-}
+}

src/LogExpert.Core/Classes/Log/LogfileReader.cs

@@ -1054,7 +1054,7 @@ private void ReadToBufferList (ILogFileInfo logFileInfo, long filePos, int start
                 var droppedLines = logBuffer.PrevBuffersDroppedLinesSum;
                 filePos = reader.Position;
 
-                while (ReadLine(reader, logBuffer.StartLine + logBuffer.LineCount, logBuffer.StartLine + logBuffer.LineCount + droppedLines, out var line))
+                while (ReadLineMemory(reader, logBuffer.StartLine + logBuffer.LineCount, logBuffer.StartLine + logBuffer.LineCount + droppedLines, out var line))
                 {
                     if (_shouldStop)
                     {
@@ -1447,7 +1447,7 @@ private void ReReadBuffer (LogBuffer logBuffer)
                 var dropCount = logBuffer.PrevBuffersDroppedLinesSum;
                 logBuffer.ClearLines();
 
-                while (ReadLine(reader, logBuffer.StartLine + logBuffer.LineCount, logBuffer.StartLine + logBuffer.LineCount + dropCount, out var line))
+                while (ReadLineMemory(reader, logBuffer.StartLine + logBuffer.LineCount, logBuffer.StartLine + logBuffer.LineCount + dropCount, out var line))
                 {
                     if (lineCount >= maxLinesCount)
                     {
@@ -1759,9 +1759,8 @@ private ILogStreamReader CreateLogStreamReader (Stream stream, EncodingOptions e
         {
             ReaderType.Legacy => new PositionAwareStreamReaderLegacy(stream, encodingOptions, _maximumLineLength),
             ReaderType.System => new PositionAwareStreamReaderSystem(stream, encodingOptions, _maximumLineLength),
-            ReaderType.Pipeline => new PositionAwareStreamReaderPipeline(stream, encodingOptions, _maximumLineLength),
-            _ => //Default will be Pipeline
-                 new PositionAwareStreamReaderPipeline(stream, encodingOptions, _maximumLineLength)
+            //Default will be System
+            _ => new PositionAwareStreamReaderSystem(stream, encodingOptions, _maximumLineLength),
         };
     }
 
@@ -1800,6 +1799,23 @@ private bool ReadLine (ILogStreamReader reader, int lineNum, int realLineNum, ou
         return true;
     }
 
+    private bool ReadLineMemory (ILogStreamReader reader, int lineNum, int realLineNum, out string outLine)
+    {
+        if (reader is ILogStreamReaderMemory memoryReader)
+        {
+            if (memoryReader.TryReadLine(out var lineMemory))
+            {
+                var line = lineMemory.ToString(); // Still converts to string
+                                                  // ... preprocessing ...
+                memoryReader.ReturnMemory(lineMemory);
+                outLine = line;
+                return true;
+            }
+        }
+
+        return ReadLine(reader, lineNum, realLineNum, out outLine);
+    }
+
     private void AcquireBufferListUpgradeableReadLock ()
     {
         if (!_bufferListLock.TryEnterUpgradeableReadLock(TimeSpan.FromSeconds(10)))

src/LogExpert.Core/Classes/Log/PositionAwareStreamReaderBase.cs

@@ -6,9 +6,8 @@ namespace LogExpert.Core.Classes.Log;
 
 public abstract class PositionAwareStreamReaderBase : LogStreamReaderBase
 {
-    #region Fields
 
-    private static readonly Encoding[] _preambleEncodings = [Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode, Encoding.UTF32];
+    #region Fields
 
     private readonly BufferedStream _stream;
     private readonly StreamReader _reader;
@@ -18,19 +17,39 @@ public abstract class PositionAwareStreamReaderBase : LogStreamReaderBase
 
     private long _position;
 
+    private static readonly Encoding[] _preambleEncodings =
+    [
+        Encoding.UTF8,
+        Encoding.Unicode,
+        Encoding.BigEndianUnicode,
+        Encoding.UTF32
+    ];
+
     #endregion
 
     #region cTor
 
     protected PositionAwareStreamReaderBase (Stream stream, EncodingOptions encodingOptions, int maximumLineLength)
     {
+        ArgumentNullException.ThrowIfNull(stream);
+
+        if (!stream.CanRead)
+        {
+            throw new ArgumentException("Stream must support reading.", nameof(stream));
+        }
+
+        if (!stream.CanSeek)
+        {
+            throw new ArgumentException("Stream must support seeking.", nameof(stream));
+        }
+
         _stream = new BufferedStream(stream);
 
         MaximumLineLength = maximumLineLength;
 
         _preambleLength = DetectPreambleLengthAndEncoding(out var detectedEncoding);
 
-        var usedEncoding = GetUsedEncoding(encodingOptions, detectedEncoding);
+        var usedEncoding = DetermineEncoding(encodingOptions, detectedEncoding);
         _posIncPrecomputed = GetPosIncPrecomputed(usedEncoding);
 
         _reader = new StreamReader(_stream, usedEncoding, true);
@@ -59,8 +78,8 @@ public sealed override long Position
              *    always delivers a fixed length (does not mater what kind of data)
              */
             _position = value; //  +Encoding.GetPreamble().Length;      // 1
-            //stream.Seek(pos, SeekOrigin.Begin);     // 2
-            //stream.Seek(pos + Encoding.GetPreamble().Length, SeekOrigin.Begin);  // 3
+                               //stream.Seek(pos, SeekOrigin.Begin);     // 2
+                               //stream.Seek(pos + Encoding.GetPreamble().Length, SeekOrigin.Begin);  // 3
             _ = _stream.Seek(_position + _preambleLength, SeekOrigin.Begin); // 4
 
             ResetReader();
@@ -124,6 +143,8 @@ public override unsafe int ReadChar ()
         }
     }
 
+
+
     protected virtual void ResetReader ()
     {
         _reader.DiscardBufferedData();
@@ -158,19 +179,42 @@ private int DetectPreambleLengthAndEncoding (out Encoding detectedEncoding)
         UTF-32-Little-Endian-Byteorder: FF FE 00 00
         */
 
-        var readPreamble = new byte[4];
+        var (length, encoding) = DetectPreambleLength(_stream);
+        // not found or less than 2 byte read
+        detectedEncoding = encoding;
+
+        return length;
+    }
 
-        var readLen = _stream.Read(readPreamble, 0, 4);
+    public static Encoding DetermineEncoding (EncodingOptions options, Encoding detectedEncoding)
+    {
+        return options?.Encoding != null
+            ? options.Encoding
+            : detectedEncoding ?? options?.DefaultEncoding ?? Encoding.Default;
+    }
 
-        if (readLen >= 2)
+    public static (int length, Encoding? detectedEncoding) DetectPreambleLength (Stream stream)
+    {
+        if (!stream.CanSeek)
+        {
+            return (0, null);
+        }
+
+        var originalPos = stream.Position;
+        var buffer = new byte[4];
+        _ = stream.Seek(0, SeekOrigin.Begin);
+        var readBytes = stream.Read(buffer, 0, buffer.Length);
+        _ = stream.Seek(originalPos, SeekOrigin.Begin);
+
+        if (readBytes >= 2)
         {
             foreach (var encoding in _preambleEncodings)
             {
                 var preamble = encoding.GetPreamble();
                 var fail = false;
-                for (var i = 0; i < readLen && i < preamble.Length; ++i)
+                for (var i = 0; i < readBytes && i < preamble.Length; ++i)
                 {
-                    if (readPreamble[i] != preamble[i])
+                    if (buffer[i] != preamble[i])
                     {
                         fail = true;
                         break;
@@ -179,26 +223,15 @@ private int DetectPreambleLengthAndEncoding (out Encoding detectedEncoding)
 
                 if (!fail)
                 {
-                    detectedEncoding = encoding;
-                    return preamble.Length;
+                    return (preamble.Length, encoding);
                 }
             }
         }
 
-        // not found or less than 2 byte read
-        detectedEncoding = null;
-
-        return 0;
+        return (0, null);
     }
 
-    private static Encoding GetUsedEncoding (EncodingOptions encodingOptions, Encoding detectedEncoding)
-    {
-        return encodingOptions.Encoding ??
-               detectedEncoding ??
-               encodingOptions.DefaultEncoding ??
-               Encoding.Default;
-    }
-    private static int GetPosIncPrecomputed (Encoding usedEncoding)
+    public static int GetPosIncPrecomputed (Encoding usedEncoding)
     {
         switch (usedEncoding)
         {