New reader

src/ColumnizerLib/IColumnizedLogLine.cs

@@ -1,8 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
 namespace ColumnizerLib;
 
 public interface IColumnizedLogLine
@@ -11,7 +6,6 @@ public interface IColumnizedLogLine
 
     ILogLine LogLine { get; }
 
-
     IColumn[] ColumnValues { get; }
 
     #endregion

src/ColumnizerLib/IColumnizerConfigurator.cs

@@ -15,7 +15,7 @@ public interface IColumnizerConfigurator
     /// required settings.
     /// </summary>
     /// <param name="callback">Callback interface with functions which can be used by the columnizer</param>
-    /// <param name="configDir">The complete path to the directory where LogExpert stores its settings. 
+    /// <param name="configDir">The complete path to the directory where LogExpert stores its settings.
     /// You can use this directory, if you want to. Please don't use the file name "settings.dat", because this
     /// name is used by LogExpert.
     /// </param>
@@ -24,21 +24,21 @@ public interface IColumnizerConfigurator
     /// It's also your own job to store the configuration in a config file or on the registry.
     /// The callback is passed to this function just in case you need the file name of the current log file
     /// or the line count etc. You can also use it to store different settings for every log file.
-    /// You can use the callback to distinguish between different files. Its passed to all important 
+    /// You can use the callback to distinguish between different files. Its passed to all important
     /// functions in the Columnizer.
     /// </remarks>
-    void Configure(ILogLineColumnizerCallback callback, string configDir);
+    void Configure (ILogLineColumnizerCallback callback, string configDir);
 
     /// <summary>
     /// This function will be called right after LogExpert has loaded your Columnizer class. Use this
     /// to load the configuration which was saved in the Configure() function.
     /// You have to hold the loaded config data in your Columnizer object.
     /// </summary>
-    /// <param name="configDir">The complete path to the directory where LogExpert stores its settings. 
+    /// <param name="configDir">The complete path to the directory where LogExpert stores its settings.
     /// You can use this directory, if you want to. Please don't use the file name "settings.dat", because this
     /// name is used by LogExpert.
     /// </param>
-    void LoadConfig(string configDir);
+    void LoadConfig (string configDir);
 
     #endregion
 }

src/ColumnizerLib/IColumnizerPriority.cs

@@ -1,8 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
 namespace ColumnizerLib;
 
 public interface IColumnizerPriority
@@ -13,5 +8,5 @@ public interface IColumnizerPriority
     /// <param name="samples"></param>
     /// <param name="fileName"></param>
     /// <returns></returns>
-    Priority GetPriority(string fileName, IEnumerable<ILogLine> samples);
+    Priority GetPriority (string fileName, IEnumerable<ILogLine> samples);
 }

src/ColumnizerLib/IFileSystemCallback.cs

@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 namespace ColumnizerLib;
 
 /// <summary>
@@ -15,7 +11,7 @@ public interface IFileSystemCallback
     /// Retrieve a logger. The plugin can use the logger to write log messages into LogExpert's log file.
     /// </summary>
     /// <returns></returns>
-    ILogExpertLogger GetLogger();
+    ILogExpertLogger GetLogger ();
 
     #endregion
 }

src/ColumnizerLib/IInitColumnizer.cs

@@ -1,11 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 namespace ColumnizerLib;
 
 /// <summary>
-/// Implement this interface in your columnizer if you need to do some initialization work 
+/// Implement this interface in your columnizer if you need to do some initialization work
 /// every time the columnizer is selected.
 /// </summary>
 /// <remarks>
@@ -14,7 +10,7 @@ namespace ColumnizerLib;
 /// heavyweight work to do in your implementations.</para>
 /// <para>
 /// If a file is reloaded, the current Columnizer is set again. That means that the methods of this
-/// interface will be called again. Generally you should do no assumptions about how often the 
+/// interface will be called again. Generally you should do no assumptions about how often the
 /// methods will be called. The file is already loaded when the columnizer is set. So
 /// you can use the methods in the given callbacks to get informations about the file or to
 /// retrieve specific lines.
@@ -28,14 +24,14 @@ public interface IInitColumnizer
     /// This method is called when the Columnizer is selected as the current columnizer.
     /// </summary>
     /// <param name="callback">Callback that can be used to retrieve some informations, if needed.</param>
-    void Selected(ILogLineColumnizerCallback callback);
+    void Selected (ILogLineColumnizerCallback callback);
 
     /// <summary>
     /// This method is called when the Columnizer is de-selected (i.e. when another Columnizer is
     /// selected).
     /// </summary>
     /// <param name="callback">Callback that can be used to retrieve some informations, if needed.</param>
-    void DeSelected(ILogLineColumnizerCallback callback);
+    void DeSelected (ILogLineColumnizerCallback callback);
 
     #endregion
 }

src/ColumnizerLib/ILogLineMemory.cs

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

src/ColumnizerLib/ILogLineSpan.cs

@@ -0,0 +1,23 @@
+public interface ILogLineSpan
+{
+    ReadOnlySpan<char> GetFullLineSpan ();
+
+    int LineNumber { get; }
+}
+
+public readonly ref struct LogLineSpan : ILogLineSpan
+{
+    private readonly ReadOnlyMemory<char> _lineMemory;
+
+    public LogLineSpan (ReadOnlyMemory<char> lineMemory, int lineNumber)
+    {
+        _lineMemory = lineMemory;
+        LineNumber = lineNumber;
+    }
+
+    public static LogLineSpan Create (ReadOnlyMemory<char> lineMemory, int lineNumber) => new LogLineSpan(lineMemory, lineNumber);
+
+    public ReadOnlySpan<char> GetFullLineSpan () => _lineMemory.Span;
+
+    public int LineNumber { get; }
+}

src/ColumnizerLib/ILogLineSpanColumnizer.cs

@@ -0,0 +1,19 @@
+namespace ColumnizerLib;
+
+public interface ILogLineSpanColumnizer : ILogLineColumnizer
+{
+    /// <summary>
+    /// Span-based version of SplitLine that avoids string allocations
+    /// </summary>
+    IColumnizedLogLine SplitLine (ILogLineColumnizerCallback callback, ReadOnlySpan<char> lineSpan, int lineNumber);
+
+    /// <summary>
+    /// Span-based timestamp extraction
+    /// </summary>
+    DateTime GetTimestamp (ILogLineColumnizerCallback callback, ReadOnlySpan<char> lineSpan, int lineNumber);
+
+    /// <summary>
+    /// Indicates if this columnizer supports span-based operations
+    /// </summary>
+    bool IsSpanSupported { get; }
+}

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/ITextValue.cs

@@ -1,10 +1,22 @@
 namespace ColumnizerLib;
 
+// DEPRECATED: This interface adds no value and causes performance overhead.
+// Keep for backward compatibility but mark as obsolete.
+[Obsolete("ITextValue is deprecated. Access FullLine or FullValue directly instead.", false)]
 public interface ITextValue
 {
     #region Properties
 
     string Text { get; }
 
     #endregion
+}
+
+public static class TextValueExtensions
+{
+    [Obsolete("Use ILogLine.FullLine property directly instead of this extension method")]
+    public static string GetText (this ILogLine logLine) => logLine.FullLine;
+
+    [Obsolete("Use DisplayValue property directly")]
+    public static string GetText (this IColumn column) => column.DisplayValue;
 }

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;
+    }
+}