added ReadOnlyMemory<char>

Author: BRUNER Patrick

src/ColumnizerLib/ILogLine.cs

@@ -9,72 +9,4 @@ public interface ILogLine : ITextValue
     int LineNumber { get; }
 
     #endregion
-}
-
-/// <summary>
-/// Represents a single log line, including its full text and line number.
-/// </summary>
-/// <remarks>
-/// <para>
-/// <b>Purpose:</b> <br/>
-/// The <c>LogLine</c> struct encapsulates the content and line number of a log entry. It is used throughout the
-/// columnizer and log processing infrastructure to provide a strongly-typed, immutable representation of a log line.
-/// </para>
-/// <para>
-/// <b>Usage:</b> <br/>
-/// This struct implements the <see cref="ILogLine"/> interface, allowing it to be used wherever an <c>ILogLine</c>
-/// is expected. It provides value semantics and is intended to be lightweight and efficiently passed by value.
-/// </para>
-/// <para>
-/// <b>Relationship to ILogLine:</b> <br/>
-/// <c>LogLine</c> is a concrete, immutable implementation of the <see cref="ILogLine"/> interface, providing
-/// properties for the full line text and its line number.
-/// </para>
-/// <para>
-/// <b>Why struct instead of record:</b> <br/>
-/// A <c>struct</c> is preferred over a <c>record</c> here to avoid heap allocations and to provide value-type
-/// semantics, which are beneficial for performance when processing large numbers of log lines. The struct is
-/// immutable (readonly), ensuring thread safety and predictability. The previous <c>record</c> implementation
-/// was replaced to better align with these performance and semantic requirements.
-/// </para>
-/// </remarks>
-public class LogLine : ILogLineMemory
-{
-    private readonly ReadOnlyMemory<char> _lineMemory;
-
-    public LogLine (string fullLine, int lineNumber)
-    {
-        FullLine = fullLine;
-        LineNumber = lineNumber;
-    }
-
-    public LogLine (ReadOnlyMemory<char> lineMemory, int lineNumber) : this(lineMemory.ToString(), lineNumber)
-    {
-        FullLineMemory = lineMemory;
-        LineNumber = lineNumber;
-    }
-
-    public string FullLine => field ??= _lineMemory.ToString();
-
-    public int LineNumber { get; }
-
-    public string Text => FullLine;
-
-    public ReadOnlyMemory<char> FullLineMemory { get; }
-
-    public override bool Equals (object obj)
-    {
-        return obj is LogLine other &&
-               FullLine == other.FullLine &&
-               LineNumber == other.LineNumber;
-    }
-
-    public override int GetHashCode ()
-    {
-        return HashCode.Combine(FullLine, LineNumber);
-    }
-
-    public static bool operator == (LogLine left, LogLine right) => left.Equals(right);
-
-    public static bool operator != (LogLine left, LogLine right) => !(left == right);
 }

src/ColumnizerLib/IPreProcessColumnizer.cs

@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 namespace ColumnizerLib;
 
 /// <summary>
@@ -20,7 +16,7 @@ namespace ColumnizerLib;
 /// <para>
 /// Note that the <see cref="PreProcessLine"/>
 /// method is only used when loading a line from disk. Because of internal buffering a log line may
-/// be read only once or multiple times. You have to ensure that the behaviour is consistent 
+/// be read only once or multiple times. You have to ensure that the behaviour is consistent
 /// for every call to <see cref="PreProcessLine"/> for a specific line. That's especially true
 /// when dropping lines. Dropping a line changes the line count seen by LogExpert. That has implications
 /// for things like bookmarks etc.
@@ -52,13 +48,14 @@ public interface IPreProcessColumnizer
     /// Detecting the first line in the file is only possible by checking the realLineNum parameter.
     /// </para>
     /// <para>
-    /// Remember that the <see cref="PreProcessLine"/> method is called in an early state 
-    /// when loading the file. So the file isn't loaded completely and the internal state 
+    /// Remember that the <see cref="PreProcessLine"/> method is called in an early state
+    /// when loading the file. So the file isn't loaded completely and the internal state
     /// of LogExpert isn't complete. You cannot make any assumptions about file size or other
     /// things. The given parameters are the only 'stateful' informations you can rely on.
     /// </para>
     /// </remarks>
-    string PreProcessLine(string logLine, int lineNum, int realLineNum);
+    string PreProcessLine (string logLine, int lineNum, int realLineNum);
 
     #endregion
-}
+}
+

src/ColumnizerLib/IPreProcessColumnizerMemory.cs

@@ -0,0 +1,55 @@
+using System.Buffers;
+
+namespace ColumnizerLib;
+
+/// <summary>
+/// <para>
+/// Implement this interface in your columnizer if you want to pre-process every line
+/// directly when it's loaded from file system.</para>
+/// <para>
+/// You can also use this to drop lines.
+/// </para>
+/// </summary>
+/// <remarks>
+/// <para>
+/// By implementing this interface with your Columnizer you get the ability to modify the
+/// content of a log file right before it will be seen by LogExpert.
+/// </para>
+/// <para>
+/// Note that the <see cref="PreProcessLine"/>
+/// method is only used when loading a line from disk. Because of internal buffering a log line may
+/// be read only once or multiple times. You have to ensure that the behaviour is consistent
+/// for every call to <see cref="PreProcessLine"/> for a specific line. That's especially true
+/// when dropping lines. Dropping a line changes the line count seen by LogExpert. That has implications
+/// for things like bookmarks etc.
+/// </para>
+/// </remarks>
+public interface IPreProcessColumnizerMemory : IPreProcessColumnizer
+{
+    #region Public methods
+
+    /// <summary>
+    /// Memory-optimized preprocessing method that returns <see cref="ReadOnlyMemory{T}"/> to avoid string allocations.
+    /// </summary>
+    /// <param name="logLine">Line content as ReadOnlyMemory</param>
+    /// <param name="lineNum">Line number as seen by LogExpert</param>
+    /// <param name="realLineNum">Actual line number in the file</param>
+    /// <returns>The changed content as <see cref="ReadOnlyMemory{T}"/>, the original memory if unchanged, or <see cref="ReadOnlyMemory{T}"/>.Empty to drop the line </returns>
+    /// <remarks>
+    /// <para>
+    /// Return values:
+    /// - Original memory: Line unchanged, no allocation
+    /// - <see cref="ReadOnlyMemory{T}"/>.Empty: Drop the line
+    /// - New memory: Modified line content
+    /// </para>
+    /// <para>
+    /// When creating modified content, consider using <see cref="ArrayPool{T}"/> to reduce allocations
+    /// for temporary buffers, but the returned memory must be owned (not pooled).
+    /// </para>
+    /// </remarks>
+    ///
+    ReadOnlyMemory<char> PreProcessLine (ReadOnlyMemory<char> logLine, int lineNum, int realLineNum);
+
+    #endregion
+}
+

src/ColumnizerLib/LogLine.cs

@@ -0,0 +1,57 @@
+namespace ColumnizerLib;
+
+/// <summary>
+/// Represents a single log line, including its full text and line number.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <b>Purpose:</b> <br/>
+/// The <c>LogLine</c> struct encapsulates the content and line number of a log entry. It is used throughout the
+/// columnizer and log processing infrastructure to provide a strongly-typed, immutable representation of a log line.
+/// </para>
+/// <para>
+/// <b>Usage:</b> <br/>
+/// This struct implements the <see cref="ILogLine"/> interface, allowing it to be used wherever an <c>ILogLine</c>
+/// is expected. It provides value semantics and is intended to be lightweight and efficiently passed by value.
+/// </para>
+/// <para>
+/// <b>Relationship to ILogLine:</b> <br/>
+/// <c>LogLine</c> is a concrete, immutable implementation of the <see cref="ILogLine"/> interface, providing
+/// properties for the full line text and its line number.
+/// </para>
+/// <para>
+/// <b>Why struct instead of record:</b> <br/>
+/// A <c>struct</c> is preferred over a <c>record</c> here to avoid heap allocations and to provide value-type
+/// semantics, which are beneficial for performance when processing large numbers of log lines. The struct is
+/// immutable (readonly), ensuring thread safety and predictability. The previous <c>record</c> implementation
+/// was replaced to better align with these performance and semantic requirements.
+/// </para>
+/// </remarks>
+public class LogLine : ILogLineMemory
+{
+    public string FullLine { get; }
+
+    public int LineNumber { get; }
+
+    public string Text { get; }
+
+    public ReadOnlyMemory<char> FullLineMemory { get; }
+
+    public ReadOnlyMemory<char> TextMemory { get; }
+
+    public LogLine (string fullLine, int lineNumber)
+    {
+        FullLine = fullLine;
+        LineNumber = lineNumber;
+        FullLineMemory = fullLine.AsMemory();
+        TextMemory = fullLine.AsMemory();
+    }
+
+    public LogLine (ReadOnlyMemory<char> fullLine, int lineNumber)
+    {
+        FullLine = fullLine.ToString();
+        LineNumber = lineNumber;
+        FullLineMemory = fullLine;
+        TextMemory = fullLine;
+    }
+}

src/CsvColumnizer/CsvColumnizer.cs

@@ -17,7 +17,7 @@ namespace CsvColumnizer;
 /// The IPreProcessColumnizer is implemented to read field names from the very first line of the file. Then
 /// the line is dropped. So it's not seen by LogExpert. The field names will be used as column names.
 /// </summary>
-public class CsvColumnizer : ILogLineColumnizer, IInitColumnizer, IColumnizerConfigurator, IPreProcessColumnizer, IColumnizerPriority
+public class CsvColumnizer : ILogLineColumnizer, IInitColumnizer, IColumnizerConfigurator, IPreProcessColumnizerMemory, IColumnizerPriority
 {
     #region Fields
 
@@ -67,6 +67,38 @@ public string PreProcessLine (string logLine, int lineNum, int realLineNum)
                     : logLine;
     }
 
+    public ReadOnlyMemory<char> PreProcessLine (ReadOnlyMemory<char> logLine, int lineNum, int realLineNum)
+    {
+        if (realLineNum == 0)
+        {
+            // store for later field names and field count retrieval
+            _firstLine = new CsvLogLine(logLine, 0);
+
+            if (_config.MinColumns > 0)
+            {
+                using CsvReader csv = new(new StringReader(logLine.ToString()), _config.ReaderConfiguration);
+                if (csv.Parser.Count < _config.MinColumns)
+                {
+                    // on invalid CSV don't hide the first line from LogExpert, since the file will be displayed in plain mode
+                    _isValidCsv = false;
+                    return logLine;
+                }
+            }
+
+            _isValidCsv = true;
+        }
+
+        if (_config.HasFieldNames && realLineNum == 0)
+        {
+            return null; // hide from LogExpert
+        }
+
+        return _config.CommentChar != ' ' &&
+               logLine.Span.StartsWith("" + _config.CommentChar, StringComparison.OrdinalIgnoreCase)
+                    ? null
+                    : logLine;
+    }
+
     public string GetName ()
     {
         return "CSV Columnizer";

src/CsvColumnizer/CsvLogLine.cs

@@ -1,16 +1,29 @@
+
 using ColumnizerLib;
 
 namespace CsvColumnizer;
 
-public class CsvLogLine(string fullLine, int lineNumber) : ILogLine
+public class CsvLogLine (string fullLine, int lineNumber) : ILogLine, ILogLineMemory
 {
     #region Properties
 
     public string FullLine { get; set; } = fullLine;
 
-    public int LineNumber { get; set; } = lineNumber;
+    public int LineNumberMemory { get; set; } = lineNumber;
 
     string ITextValue.Text => FullLine;
 
+    public ReadOnlyMemory<char> FullLineMemory { get; }
+
+    public ReadOnlyMemory<char> TextMemory { get; }
+
     #endregion
+
+    public CsvLogLine (ReadOnlyMemory<char> fullLine, int lineNumber) : this(fullLine.ToString(), lineNumber)
+    {
+        FullLine = fullLine.ToString();
+        LineNumberMemory = lineNumber;
+        FullLineMemory = fullLine;
+        TextMemory = fullLine;
+    }
 }