23 - Added TelegramImporter

- Added TelegramImporter class and unit tests
- Added optional leaveOpen argument to constructors

Author: stprograms

…itor/src/Utils/Storage/TelegramWriter.cs …or/src/Utils/Storage/TelegramExporter.csRS485 Monitor/src/Utils/Storage/TelegramWriter.cs renamed to RS485 Monitor/src/Utils/Storage/TelegramExporter.cs RS485 Monitor/src/Utils/Storage/TelegramWriter.cs renamed to RS485 Monitor/src/Utils/Storage/TelegramExporter.cs

@@ -5,24 +5,29 @@ namespace RS485_Monitor.Utils.Storage
     /// <summary>
     /// This class will export the telegrams into a binary format to a stream.
     /// </summary>
-    public class TelegramWriter :IDisposable
+    public class TelegramExporter :IDisposable
     {
         public const byte VERSION = 1;
         public const string IDENTIFIER = "RS485MONITOR";
-        public readonly byte[] MAGIC_NUMBER = Encoding.ASCII.GetBytes(IDENTIFIER);
+        public static readonly byte[] MAGIC_NUMBER = Encoding.ASCII.GetBytes(IDENTIFIER);
 
         private readonly BinaryWriter _writer;
 
-        public TelegramWriter(Stream stream)
+        /// <summary>
+        /// Create a new TelegramExporter from a stream.
+        /// </summary>
+        /// <param name="stream">stream to read from</param>
+        /// <param name="leaveOpen">leave the stream open after reading</param>
+        public TelegramExporter(Stream stream, bool leaveOpen = false)
         {
-            _writer = new BinaryWriter(stream);
+            _writer = new BinaryWriter(stream, new UTF8Encoding(), leaveOpen);
             WriteHeader();
         }
 
-        public TelegramWriter(string path)
+        public TelegramExporter(string path, bool leaveOpen = false)
         {
             FileStream stream = new(path, FileMode.Create);
-            _writer = new BinaryWriter(stream);
+            _writer = new BinaryWriter(stream, new UTF8Encoding(), leaveOpen);
             WriteHeader();
         }
 

RS485 Monitor/src/Utils/Storage/TelegramImporter.cs

@@ -0,0 +1,103 @@
+using System.Text;
+using RS485Monitor.Telegrams;
+
+namespace RS485_Monitor.Utils.Storage
+{
+    /// <summary>
+    /// This class will import telegrams from a stream created by the TelegramExporter.
+    /// </summary>
+    ///
+    public class TelegramImporter : IDisposable
+    {
+        private readonly BinaryReader _reader;
+        /// <summary>
+        /// Version read from the stream
+        /// </summary>
+        public byte FormatVersion { get; }
+
+        /// <summary>
+        /// Create a new TelegramImporter from a stream.
+        /// </summary>
+        /// <param name="stream">Stream to read from</param>
+        /// <exception cref="InvalidDataException">Invalid file format</exception>
+        public TelegramImporter(Stream stream, bool leaveOpen = false)
+        {
+            _reader = new BinaryReader(stream, new UTF8Encoding(), leaveOpen);
+            FormatVersion = ReadHeader();
+        }
+
+        /// <summary>
+        /// Create a new TelegramImporter from a file.
+        /// </summary>
+        /// <param name="path">Path to the file</param>
+        /// <exception cref="InvalidDataException">Invalid file format</exception>
+        public TelegramImporter(string path, bool leaveOpen = false)
+        {
+            FileStream stream = new(path, FileMode.Open);
+            _reader = new BinaryReader(stream, new UTF8Encoding(), leaveOpen);
+            FormatVersion = ReadHeader();
+        }
+
+        /// <summary>
+        /// Iterator function to iterate over all telegrams in the file.
+        /// </summary>
+        /// <returns>An enumerable of BaseTelegram objects.</returns>
+        public IEnumerable<BaseTelegram> GetTelegram()
+        {
+            while (_reader.BaseStream.Position < _reader.BaseStream.Length)
+            {
+                yield return PopTelegram();
+            }
+        }
+
+        public void Dispose()
+        {
+            _reader?.Dispose();
+        }
+
+        /// <summary>
+        /// Read the header of the file and check if it is a valid file.
+        /// </summary>
+        protected byte ReadHeader()
+        {
+            byte[] magic_number = _reader.ReadBytes(TelegramExporter.IDENTIFIER.Length);
+            byte version = _reader.ReadByte();
+
+            if (!magic_number.SequenceEqual(TelegramExporter.MAGIC_NUMBER) || version != TelegramExporter.VERSION)
+            {
+                throw new InvalidDataException("Invalid file format");
+            }
+
+            return version;
+        }
+
+        /// <summary>
+        /// Pop the next telegram from the stream
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="InvalidDataException">Could not find an endTag</exception>
+        /// <exception cref="EndOfStreamException"></exception>
+        protected BaseTelegram PopTelegram()
+        {
+            long timestamp = _reader.ReadInt64();
+            List<byte> raw = [];
+            byte b;
+
+            // Read until end telegram is found or max length is reached
+            do
+            {
+                b = _reader.ReadByte();
+                raw.Add(b);
+            } while (b != BaseTelegram.END_TELEGRAM && raw.Count < BaseTelegram.MAX_RAW_DATA_LEN);
+
+            if (raw.Count >= BaseTelegram.MAX_RAW_DATA_LEN)
+            {
+                throw new InvalidDataException("Endtag not found. File is corrupted.");
+            }
+
+            // Create and specialize the telegram
+            BaseTelegram baseTelegram = new(raw.ToArray<byte>(), DateTime.FromBinary(timestamp));
+            return TelegramSpecializer.Specialize(baseTelegram);
+        }
+    }
+}

tests/TelegramWriterTest.cs tests/TelegramExporterTest.cstests/TelegramWriterTest.cs renamed to tests/TelegramExporterTest.cs

@@ -4,17 +4,17 @@ namespace RS485_Monitor.tests;
 using System.Text;
 
 [TestFixture]
-public class TelegramWriterTest
+public class TelegramExporterTest
 {
 
     [Test]
     public void WriteHeaderTest()
     {
         MemoryStream stream = new();
-        using TelegramWriter writer = new(stream);
+        using TelegramExporter writer = new(stream);
 
         // Extract identifier
-        byte[] expected = Encoding.ASCII.GetBytes(TelegramWriter.IDENTIFIER);
+        byte[] expected = Encoding.ASCII.GetBytes(TelegramExporter.IDENTIFIER);
         byte[] actual = new byte[expected.Length];
 
         stream.Seek(0, SeekOrigin.Begin);
@@ -33,20 +33,20 @@ public void WriteHeaderTest()
     public void CreateFileSuccess() {
         string path = Path.GetTempFileName();
 
-        using (TelegramWriter writer = new(path)) {
+        using (TelegramExporter writer = new(path)) {
             Assert.That(File.Exists(path), Is.True);
         }
 
         using (Stream stream = new FileStream(path, FileMode.Open)) {
 
             // Read the content of the file and check the header
             using (var reader = new BinaryReader(stream)) {
-                byte[] actual = new byte[TelegramWriter.IDENTIFIER.Length];
-                reader.Read(actual, 0, TelegramWriter.IDENTIFIER.Length);
+                byte[] actual = new byte[TelegramExporter.IDENTIFIER.Length];
+                reader.Read(actual, 0, TelegramExporter.IDENTIFIER.Length);
                 byte actual_version = reader.ReadByte();
 
-                byte[] expected = Encoding.ASCII.GetBytes(TelegramWriter.IDENTIFIER);
-                byte expected_version = TelegramWriter.VERSION;
+                byte[] expected = Encoding.ASCII.GetBytes(TelegramExporter.IDENTIFIER);
+                byte expected_version = TelegramExporter.VERSION;
 
                 Assert.That(actual, Is.EqualTo(expected));
                 Assert.That(actual_version, Is.EqualTo(expected_version));
@@ -61,7 +61,7 @@ public void CreateFileSuccess() {
     [Test]
     public void PushTelegrams() {
         MemoryStream stream = new();
-        using TelegramWriter writer = new(stream);
+        using TelegramExporter writer = new(stream);
 
 
         byte[] raw1 = [0xB6, 0x6B, 0xAA, 0x5A, 0x0A, 0x4D, 0x48, 0x17, 0x00, 0x00, 0x23, 0x00, 0x0B, 0x00, 0x00, 0x30, 0x0D];
@@ -74,7 +74,7 @@ public void PushTelegrams() {
         }
 
         // Jump over the header and start reading the telegrams
-        var headerlen = TelegramWriter.IDENTIFIER.Length + 1;
+        var headerlen = TelegramExporter.IDENTIFIER.Length + 1;
         stream.Seek(headerlen, SeekOrigin.Begin);
 
         using (var reader = new BinaryReader(stream)) {

tests/TelegramImporterTest.cs

@@ -0,0 +1,61 @@
+namespace RS485_Monitor.tests;
+using RS485_Monitor.Utils.Storage;
+using NUnit.Framework;
+
+[TestFixture]
+public class TelegramImportTest
+{
+    public required Stream stream;
+    public required List<BaseTelegram> telegrams;
+
+    [OneTimeSetUp]
+    public void SetUp()
+    {
+        stream = new MemoryStream();
+        telegrams = [];
+
+        telegrams.Add(new BaseTelegram([0xB6, 0x6B, 0xAA, 0x5A, 0x0A, 0x4D, 0x48, 0x17, 0x00, 0x00, 0x23, 0x00, 0x0B, 0x00, 0x00, 0x30, 0x0D]));
+        telegrams.Add(new BaseTelegram([0xC5, 0x5C, 0x5A, 0xAA, 0x01, 0x00, 0x30, 0x0D]));
+
+        using TelegramExporter writer = new(stream, leaveOpen: true);
+        foreach (BaseTelegram telegram in telegrams)
+        {
+            writer.PushTelegram(telegram);
+        }
+    }
+
+    [OneTimeTearDown]
+    public void TearDown()
+    {
+        stream.Dispose();
+    }
+
+    [SetUp]
+    public void SetUpTest()
+    {
+        stream.Seek(0, SeekOrigin.Begin);
+    }
+
+    [Test]
+    public void ReadHeaderTest()
+    {
+        using TelegramImporter reader = new(stream, leaveOpen: true);
+        Assert.That(reader.FormatVersion, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void ReadTelegrams()
+    {
+        using TelegramImporter reader = new(stream, leaveOpen: true);
+        List<BaseTelegram> actual = [];
+
+        // read the telegrams
+        foreach (BaseTelegram telegram in reader.GetTelegram())
+        {
+            actual.Add(telegram);
+        }
+
+        // Check that the read telegrams are the same as the ones we wrote
+        Assert.That(actual, Is.EqualTo(telegrams));
+    }
+}