vcd muliticore parsing

src/OneWare.Settings/SettingsService.cs

@@ -69,6 +69,18 @@ public T GetSettingValue<T>(string key)
         throw new ArgumentException($"Setting {key} is not registered!");
     }
 
+    public T[] GetComboOptions<T>(string key)
+    {
+        Settings.TryGetValue(key, out var value);
+        if (value is ComboBoxSetting cs && value?.Value is T)
+        {
+            var destinationArray = new T[cs.Options.Length];
+            Array.Copy(cs.Options, destinationArray, cs.Options.Length);
+            return destinationArray;
+        }
+        throw new ArgumentException($"Setting {key} is not registered!");
+    }
+
     public void SetSettingValue(string key, object value)
     {
         Settings.TryGetValue(key, out var s);

src/OneWare.Shared/Services/ISettingsService.cs

@@ -15,9 +15,11 @@ public void RegisterTitled<T>(string category, string subCategory, string key, s
 
     public void RegisterTitledCombo<T>(string category, string subCategory, string key, string title, string description,
         T defaultValue, params T[] options);
-
+    
     public T GetSettingValue<T>(string key);
 
+    public T[] GetComboOptions<T>(string key);
+
     public void SetSettingValue(string key, object value);
 
     public IObservable<T> GetSettingObservable<T>(string key);

src/OneWare.Vcd.Parser/Data/IVcdSignal.cs

@@ -7,10 +7,12 @@ public interface IVcdSignal
     public string Name { get; }
     public char Id { get; }
     public void AddChange(int time, object change);
+    public void AddChanges(IVcdSignal signal);
     public void Clear();
     public int FindIndex(long offset);
     public object? GetValueFromOffset(long offset);
     public long GetChangeTimeFromIndex(int index);
     public object? GetValueFromIndex(int index);
     public void Invalidate();
+    public IVcdSignal CloneEmpty();
 }

src/OneWare.Vcd.Parser/Data/VcdFile.cs

@@ -2,6 +2,7 @@
 
 public class VcdFile
 {
+    public long DefinitionParseEndPosition { get; set; }
     public VcdDefinition Definition { get; }
 
     public VcdFile(VcdDefinition definition)

src/OneWare.Vcd.Parser/Data/VcdSignal.cs

@@ -29,6 +29,17 @@ public void AddChange(int timeIndex, object change)
         _changeTimeOffsets.Add(timeIndex);
         _values.Add((T)change);
     }
+
+    public void AddChanges(IVcdSignal signal)
+    {
+        if (signal is not VcdSignal<T> s) return;
+        var offset = ChangeTimes.Count;
+        foreach (var off in s._changeTimeOffsets)
+        {
+            _changeTimeOffsets.Add(off+offset);
+        }
+        _values.AddRange(s._values);
+    }
 
     public void Clear()
     {
@@ -79,4 +90,9 @@ public void Invalidate()
     {
         RequestRedraw?.Invoke(null, EventArgs.Empty);
     }
+
+    public IVcdSignal CloneEmpty()
+    {
+        return new VcdSignal<T>(new List<long>(), Type, BitWidth, Id, Name);
+    }
 }

src/OneWare.Vcd.Parser/Extensions/StreamReadLimitLengthWrapper.cs

@@ -0,0 +1,133 @@
+namespace OneWare.Vcd.Parser.Extensions;
+
+sealed class StreamReadLimitLengthWrapper : Stream
+{
+    private readonly Stream _mInnerStream;
+
+    public StreamReadLimitLengthWrapper(Stream innerStream, long size)
+    {
+        if (size < 0) throw new ArgumentOutOfRangeException(nameof(size));
+
+        _mInnerStream = innerStream;
+        Length = _mInnerStream.Position + size;
+    }
+
+    public override bool CanRead => _mInnerStream.CanRead;
+
+    public override bool CanSeek => _mInnerStream.CanSeek;
+
+    public override bool CanWrite => false;
+
+    public override void Flush()
+    {
+        _mInnerStream.Flush();
+    }
+
+    public override long Length { get; }
+
+    public override long Position
+    {
+        get => _mInnerStream.Position;
+        set => _mInnerStream.Position = value;
+    }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        count = GetAllowedCount(count);
+        return _mInnerStream.Read(buffer, offset, count);
+    }
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        return _mInnerStream.Seek(offset, origin);
+    }
+
+    public override void SetLength(long value)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override bool CanTimeout => _mInnerStream.CanTimeout;
+
+    public override int ReadTimeout
+    {
+        get => _mInnerStream.ReadTimeout;
+        set => _mInnerStream.ReadTimeout = value;
+    }
+
+    public override int WriteTimeout
+    {
+        get => _mInnerStream.ReadTimeout;
+        set => _mInnerStream.ReadTimeout = value;
+    }
+
+    public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
+    {
+        count = GetAllowedCount(count);
+        return _mInnerStream.BeginRead(buffer, offset, count, callback, state);
+    }
+
+    public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void Close()
+    {
+        // Since this wrapper does not own the underlying stream, we do not want it to close the underlying stream
+    }
+
+    public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
+    {
+        return _mInnerStream.CopyToAsync(destination, bufferSize, cancellationToken);
+    }
+
+    public override int EndRead(IAsyncResult asyncResult)
+    {
+        return _mInnerStream.EndRead(asyncResult);
+    }
+
+    public override Task FlushAsync(CancellationToken cancellationToken)
+    {
+        return _mInnerStream.FlushAsync(cancellationToken);
+    }
+
+    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    {
+        count = GetAllowedCount(count);
+        return _mInnerStream.ReadAsync(buffer, offset, count, cancellationToken);
+    }
+
+    public override int ReadByte()
+    {
+        var count = GetAllowedCount(1);
+        if (count == 0)
+            return -1;
+
+        return _mInnerStream.ReadByte();
+    }
+
+    public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+    {
+        throw new NotSupportedException();
+    }
+
+    public override void WriteByte(byte value)
+    {
+        throw new NotSupportedException();
+    }
+
+    private int GetAllowedCount(int count)
+    {
+        var pos = _mInnerStream.Position;
+        var maxCount = Length - pos;
+        if (count > maxCount)
+            count = (int)maxCount;
+        return count;
+    }
+}