A lot of Memory

Author: BRUNER Patrick

src/AutoColumnizer/AutoColumnizer.cs

@@ -39,7 +39,7 @@ public string[] GetColumnNames ()
         throw new NotImplementedException();
     }
 
-    public IColumnizedLogLineMemory SplitLine (ILogLineColumnizerCallback callback, ILogLine line)
+    public IColumnizedLogLine SplitLine (ILogLineColumnizerCallback callback, ILogLine line)
     {
         throw new NotImplementedException();
     }

src/ColumnizerLib/Column.cs

@@ -11,14 +11,14 @@ public class Column : IColumnMemory
     // Can be configured via SetMaxDisplayLength()
     private static int _maxDisplayLength = 20_000;
 
-    private static readonly List<Func<string, string>> _replacements = [
+    private static readonly List<Func<ReadOnlyMemory<char>, ReadOnlyMemory<char>>> _replacementsMemory = [
         //replace tab with 3 spaces, from old coding. Needed???
-                input => input.Replace("\t", "  ", StringComparison.Ordinal),
+        ReplaceTab,
 
-                //shorten string if it exceeds maxLength
-                input => input.Length > _maxDisplayLength
-                        ? string.Concat(input.AsSpan(0, _maxDisplayLength), REPLACEMENT)
-                        : input
+        //shorten string if it exceeds maxLength
+        input => input.Length > _maxDisplayLength
+                ? ShortenMemory(input, _maxDisplayLength)
+                : input
     ];
 
     #endregion
@@ -31,7 +31,7 @@ static Column ()
         {
             //Win8 or newer support full UTF8 chars with the preinstalled fonts.
             //Replace null char with UTF8 Symbol U+2400 (␀)
-            _replacements.Add(input => input.Replace("\0", "␀", StringComparison.Ordinal));
+            _replacementsMemory.Add(input => ReplaceNullChar(input, '␀'));
         }
         else
         {
@@ -40,10 +40,10 @@ static Column ()
             //.net 10 does no longer support windows lower then windows 10
             //TODO: remove if with one of the next releases
             //https://github.com/dotnet/core/blob/main/release-notes/10.0/supported-os.md
-            _replacements.Add(input => input.Replace("\0", " ", StringComparison.Ordinal));
+            _replacementsMemory.Add(input => ReplaceNullChar(input, ' '));
         }
 
-        EmptyColumn = new Column { FullValue = string.Empty };
+        EmptyColumn = new Column { FullValue = ReadOnlyMemory<char>.Empty };
     }
 
     #endregion
@@ -52,18 +52,49 @@ static Column ()
 
     public static IColumnMemory EmptyColumn { get; }
 
-    public IColumnizedLogLineMemory Parent { get; set; }
+    [Obsolete]
+    IColumnizedLogLine IColumn.Parent { get; }
 
-    public string FullValue
+    [Obsolete]
+    string IColumn.FullValue
+    {
+        get;
+        //set
+        //{
+        //    field = value;
+
+        //    var temp = FullValue.ToString();
+
+        //    foreach (var replacement in _replacements)
+        //    {
+        //        temp = replacement(temp);
+        //    }
+
+        //    DisplayValue = temp.AsMemory();
+        //}
+    }
+
+    [Obsolete("Use the DisplayValue property of IColumnMemory")]
+    string IColumn.DisplayValue { get; }
+
+    [Obsolete("Use Text property of ITextValueMemory")]
+    string ITextValue.Text => DisplayValue.ToString();
+
+    public IColumnizedLogLineMemory Parent
+    {
+        get; set => field = value;
+    }
+
+    public ReadOnlyMemory<char> FullValue
     {
         get;
         set
         {
             field = value;
 
-            var temp = FullValue;
+            var temp = value;
 
-            foreach (var replacement in _replacements)
+            foreach (var replacement in _replacementsMemory)
             {
                 temp = replacement(temp);
             }
@@ -72,22 +103,9 @@ public string FullValue
         }
     }
 
-    public string DisplayValue { get; private set; }
+    public ReadOnlyMemory<char> DisplayValue { get; private set; }
 
-    public string Text => DisplayValue;
-
-    public IColumnizedLogLineMemory ParentMemory { get; }
-
-    public ReadOnlyMemory<char> FullValueMemory
-    {
-        get;
-        set; //implement
-    }
-
-    public ReadOnlyMemory<char> DisplayValueMemory { get; }
-
-    public ReadOnlyMemory<char> TextMemory { get; }
-    IColumnizedLogLine IColumn.Parent { get; }
+    public ReadOnlyMemory<char> Text => DisplayValue;
 
     #endregion
 
@@ -115,10 +133,10 @@ public static void SetMaxDisplayLength (int maxLength)
 
     public static Column[] CreateColumns (int count, IColumnizedLogLineMemory parent)
     {
-        return CreateColumns(count, parent, string.Empty);
+        return CreateColumns(count, parent, ReadOnlyMemory<char>.Empty);
     }
 
-    public static Column[] CreateColumns (int count, IColumnizedLogLineMemory parent, string defaultValue)
+    public static Column[] CreateColumns (int count, IColumnizedLogLineMemory parent, ReadOnlyMemory<char> defaultValue)
     {
         var output = new Column[count];
 
@@ -132,7 +150,95 @@ public static Column[] CreateColumns (int count, IColumnizedLogLineMemory parent
 
     public override string ToString ()
     {
-        return DisplayValue ?? string.Empty;
+        return DisplayValue.ToString() ?? ReadOnlyMemory<char>.Empty.ToString();
+    }
+
+    #endregion
+
+    #region Private Methods
+
+    /// <summary>
+    /// Replaces tab characters with two spaces in the memory buffer.
+    /// </summary>
+    private static ReadOnlyMemory<char> ReplaceTab (ReadOnlyMemory<char> input)
+    {
+        var span = input.Span;
+        var tabIndex = span.IndexOf('\t');
+
+        if (tabIndex == -1)
+        {
+            return input;
+        }
+
+        // Count total tabs to calculate new length
+        var tabCount = 0;
+        foreach (var c in span)
+        {
+            if (c == '\t')
+            {
+                tabCount++;
+            }
+        }
+
+        // Allocate new buffer: original length + (tabCount * 1) since we replace 1 char with 2
+        var newLength = input.Length + tabCount;
+        var buffer = new char[newLength];
+        var bufferPos = 0;
+
+        for (var i = 0; i < span.Length; i++)
+        {
+            if (span[i] == '\t')
+            {
+                buffer[bufferPos++] = ' ';
+                buffer[bufferPos++] = ' ';
+            }
+            else
+            {
+                buffer[bufferPos++] = span[i];
+            }
+        }
+
+        return buffer;
+    }
+
+    /// <summary>
+    /// Shortens the memory buffer to the specified maximum length and appends "...".
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Non Localiced Parameter")]
+    private static ReadOnlyMemory<char> ShortenMemory (ReadOnlyMemory<char> input, int maxLength)
+    {
+        var buffer = new char[maxLength + REPLACEMENT.Length];
+        input.Span[..maxLength].CopyTo(buffer);
+        REPLACEMENT.AsSpan().CopyTo(buffer.AsSpan(maxLength));
+        return buffer;
+    }
+
+    /// <summary>
+    /// Replaces null characters with the specified replacement character.
+    /// </summary>
+    private static ReadOnlyMemory<char> ReplaceNullChar (ReadOnlyMemory<char> input, char replacement)
+    {
+        var span = input.Span;
+        var nullIndex = span.IndexOf('\0');
+
+        if (nullIndex == -1)
+        {
+            return input;
+        }
+
+        // Need to create a new buffer since we're modifying content
+        var buffer = new char[input.Length];
+        span.CopyTo(buffer);
+
+        for (var i = 0; i < buffer.Length; i++)
+        {
+            if (buffer[i] == '\0')
+            {
+                buffer[i] = replacement;
+            }
+        }
+
+        return buffer;
     }
 
     #endregion

src/ColumnizerLib/ColumnizedLogLine.cs

@@ -4,13 +4,15 @@ public class ColumnizedLogLine : IColumnizedLogLineMemory
 {
     #region Properties
 
-    public ILogLine LogLine { get; set; }
+    [Obsolete("Use the Property of IColumnizedLogLineMemory")]
+    ILogLine IColumnizedLogLine.LogLine { get; }
 
-    public IColumn[] ColumnValues { get; set; }
+    [Obsolete("Use the Property of IColumnizedLogLineMemory")]
+    IColumn[] IColumnizedLogLine.ColumnValues { get; }
 
-    public ILogLineMemory LogLineMemory { get; set; }
+    public ILogLineMemory LogLine { get; set; }
 
-    public IColumnMemory[] ColumnMemoryValues { get; set; }
+    public IColumnMemory[] ColumnValues { get; set; }
 
     #endregion
 }

src/ColumnizerLib/IColumnMemory.cs

@@ -4,11 +4,11 @@ public interface IColumnMemory : IColumn, ITextValueMemory
 {
     #region Properties
 
-    IColumnizedLogLineMemory ParentMemory { get; }
+    new IColumnizedLogLineMemory Parent { get; }
 
-    ReadOnlyMemory<char> FullValueMemory { get; }
+    new ReadOnlyMemory<char> FullValue { get; }
 
-    ReadOnlyMemory<char> DisplayValueMemory { get; }
+    new ReadOnlyMemory<char> DisplayValue { get; }
 
     #endregion
 }

src/ColumnizerLib/IColumnizedLogLineMemory.cs

@@ -4,9 +4,9 @@ public interface IColumnizedLogLineMemory : IColumnizedLogLine
 {
     #region Properties
 
-    ILogLineMemory LogLineMemory { get; }
+    new ILogLineMemory LogLine { get; }
 
-    IColumnMemory[] ColumnMemoryValues { get; }
+    new IColumnMemory[] ColumnValues { get; }
 
     #endregion
 }

src/ColumnizerLib/IColumnizerConfiguratorMemory.cs

@@ -0,0 +1,33 @@
+namespace ColumnizerLib;
+
+/// <summary>
+/// A Columnizer can implement this interface if it has to show an own settings dialog to the user.
+/// The Config button in LogExpert's columnizer dialog is enabled if a Columnizer implements this interface.
+/// If you don't need a config dialog you don't have to implement this interface.
+/// </summary>
+public interface IColumnizerConfiguratorMemory : IColumnizerConfigurator
+{
+    #region Public methods
+
+    /// <summary>
+    /// This function is called if the user presses the Config button on the Columnizer dialog.
+    /// Its up to the Columnizer plugin to show an own configuration dialog and store all
+    /// 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.
+    /// 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>
+    /// <remarks>
+    /// This is the place to show a configuration dialog to the user. You have to handle all dialog stuff by yourself.
+    /// 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
+    /// functions in the Columnizer.
+    /// </remarks>
+    void Configure (ILogLineMemoryColumnizerCallback callback, string configDir);
+
+    #endregion
+}

src/ColumnizerLib/IInitColumnizerMemory.cs

@@ -0,0 +1,37 @@
+namespace ColumnizerLib;
+
+/// <summary>
+/// Implement this interface in your columnizer if you need to do some initialization work
+/// every time the columnizer is selected.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The methods in this interface will be called in the GUI thread. So make sure that there's no
+/// 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
+/// 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.
+/// </para>
+/// </remarks>
+public interface IInitColumnizerMemory : IInitColumnizer
+{
+    #region Public methods
+
+    /// <summary>
+    /// 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 (ILogLineMemoryColumnizerCallback 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 (ILogLineMemoryColumnizerCallback callback);
+
+    #endregion
+}