implement FinalElementAttribute

ByteSerialization.Tests/Integration/Attributes/FinalElement/FinalElementAttributeTest.cs

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+
+using ByteSerialization.IO;
+using ByteSerialization.Tests.Integration.Attributes.FinalElement.TestObjects;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace ByteSerialization.Tests.Integration.Attributes.FinalElement
+{
+    public class FinalElementAttributeTest(ITestOutputHelper testOutputHelper) :
+        IntegrationTestBase(testOutputHelper)
+    {
+        #region Fields
+
+        private static readonly byte[] TestBytes =
+            HexStringConverter.ToByteArray("01 02 03 FF 05");
+
+        private static readonly ListContainer TestObject = new()
+        {
+            Bytes = [1, 2, 3, 0xFF],
+            EndByte = 5,
+        };
+
+        #endregion
+
+        #region Methods
+
+        [Fact]
+        public void Test_Deserialization() =>
+            AssertDeserializedObject(
+                TestObject, TestBytes, Endianness.BigEndian);
+
+        [Fact]
+        public void Test_Serialization() =>
+            AssertSerializedObject(
+                TestBytes, TestObject, Endianness.BigEndian);
+
+        #endregion
+    }
+}

ByteSerialization.Tests/Integration/Attributes/FinalElement/TestObjects/ListContainer.cs

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+
+using ByteSerialization.Attributes;
+using ByteSerialization.IO;
+
+namespace ByteSerialization.Tests.Integration.Attributes.FinalElement.TestObjects
+{
+    internal class ListContainer
+    {
+        #region Properties
+
+        [Order(0), FinalElement(byte.MaxValue)]
+        public List<byte> Bytes { get; set; }
+        [Order(1)]
+        public byte EndByte { get; set; }
+
+        #endregion
+
+        #region Methods (: object)
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ListContainer other)
+            {
+                if (!Enumerable.SequenceEqual(Bytes, other.Bytes))
+                    return false;
+                if (!Equals(EndByte, other.EndByte))
+                    return false;
+                return true;
+            }
+            else
+                return false;
+        }
+
+        public override int GetHashCode() =>
+            HashCode.Combine(
+                HashCodeHelper.CombineHashCodes(Bytes?.ToArray()), 
+                EndByte);
+
+        #endregion
+    }
+}

ByteSerialization/Attributes/FinalElementAttribute.cs

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+using ByteSerialization.Components.Attributes.Limiting;
+using System;
+
+namespace ByteSerialization.Attributes
+{
+    [AttributeComponent(typeof(FinalElementComponent))]
+    [AttributeUsage(AttributeTargets.Property)]
+    public class FinalElementAttribute : ByteSerializationAttribute
+    {
+        #region Properties
+
+        public object Value { get; }
+        public Type ValueType { get; }
+
+        #endregion
+
+        #region Constructor
+
+        public FinalElementAttribute(object value) =>
+            Value = value;
+
+        public FinalElementAttribute(Type valueType) =>
+            ValueType = valueType;
+
+        #endregion
+    }
+}

ByteSerialization/ByteSerialization.csproj

@@ -5,7 +5,7 @@
     <Nullable>disable</Nullable>
     <Authors>Alexander Kopetsch</Authors>
     <Version>0.0.1.0</Version>
-    <PackageVersion>0.0.1-alpha.9</PackageVersion>
+    <PackageVersion>0.0.1-alpha.10</PackageVersion>
     <PackageProjectUrl>https://github.com/akopetsch/ByteSerialization</PackageProjectUrl>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>

ByteSerialization/Components/Attributes/Limiting/FinalElementComponent.cs

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+
+using ByteSerialization.Attributes;
+using ByteSerialization.Attributes.Limiting;
+using ByteSerialization.Components.Values.Composites.Collections;
+using System;
+using System.Linq;
+
+namespace ByteSerialization.Components.Attributes.Limiting
+{
+    public class FinalElementComponent :
+        AttributeComponent<FinalElementAttribute>, ILimitingComponent
+    {
+        #region Properties
+
+        private object _expectedFinalElementValue;
+
+        #endregion
+
+        #region Methods
+
+        protected override void OnInitialized()
+        {
+            base.OnInitialized();
+            _expectedFinalElementValue = Attribute.Value ?? Activator.CreateInstance(Attribute.ValueType);
+        }
+
+        public bool IsDeserializedUntilEnd(CollectionComponent collection) =>
+            collection.Elements.LastOrDefault()?.Value.Equals(_expectedFinalElementValue) ?? false;
+
+        #endregion
+    }
+}