rust enum wrapper (#91)

* a new try to wrap rust enums

* added reference to TEnum, for better readability

* adding a similar solution for the BaseTuple

* updated to rc4

Author: darkfriend77

Substrate.NetApi.Test/TypeConverters/EnumRustTest.cs

@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using Substrate.NetApi.Model.Types.Base;
+using Substrate.NetApi.Model.Types.Primitive;
+using System;
+using System.Collections.Generic;
+
+namespace Substrate.NetApi.Tests
+{
+    public enum PhaseState
+    {
+        None = 0,
+        Finalization = 1,
+        Initialization = 2
+    }
+
+    [TestFixture]
+    public class BaseEnumRustTests
+    {
+        [Test]
+        public void ExtEnumEncodingTest()
+        {
+            var typeDecoderMap = new Dictionary<PhaseState, Type>
+            {
+                { PhaseState.None, typeof(U8) },
+                { PhaseState.Finalization, typeof(BaseVoid) },
+                { PhaseState.Initialization, typeof(BaseVoid) }
+            };
+
+            var extEnumType = new BaseEnumRust<PhaseState>(typeDecoderMap);
+
+            int p = 0;
+            extEnumType.Decode(new byte[] { 0x00, 0x01 }, ref p);
+
+            Assert.AreEqual(PhaseState.None, extEnumType.Value);
+            Assert.AreEqual("U8", extEnumType.Value2.GetType().Name);
+            Assert.AreEqual(1, (extEnumType.Value2 as U8).Value);
+        }
+
+        [Test]
+        public void ExtEnumDencodingTest()
+        {
+            var typeDecoderMap = new Dictionary<PhaseState, Type>
+            {
+                { PhaseState.None, typeof(U8) },
+                { PhaseState.Finalization, typeof(BaseVoid) },
+                { PhaseState.Initialization, typeof(BaseVoid) }
+            };
+
+            var extEnumType = new BaseEnumRust<PhaseState>(typeDecoderMap);
+
+            int p = 0;
+            extEnumType.Decode(new byte[] { 0x00, 0x01 }, ref p);
+
+            Assert.AreEqual(PhaseState.None, extEnumType.Value);
+            Assert.AreEqual("U8", extEnumType.Value2.GetType().Name);
+            Assert.AreEqual(1, (extEnumType.Value2 as U8).Value);
+
+            Assert.AreEqual(new byte[] { 0x00, 0x01 }, extEnumType.Bytes);
+        }
+
+        [Test]
+        public void ExtEnumCreateTest()
+        {
+            var typeDecoderMap = new Dictionary<PhaseState, Type>
+            {
+                { PhaseState.None, typeof(U8) },
+                { PhaseState.Finalization, typeof(BaseVoid) },
+                { PhaseState.Initialization, typeof(BaseVoid) }
+            };
+
+            var u8 = new U8(1);
+            var byValue = new BaseEnumRust<PhaseState>(typeDecoderMap);
+            byValue.Create(PhaseState.None, u8);
+
+            var byArray = new BaseEnumRust<PhaseState>();
+            byArray.AddTypeDecoder<U8>(PhaseState.None);
+            byArray.AddTypeDecoder<BaseVoid>(PhaseState.Finalization);
+            byArray.AddTypeDecoder<BaseVoid>(PhaseState.Initialization);
+            byArray.Create(new byte[] { 0, 1 });
+
+            var byHex = new BaseEnumRust<PhaseState>();
+            byHex.AddTypeDecoder<U8>(PhaseState.None);
+            byHex.AddTypeDecoder<BaseVoid>(PhaseState.Finalization);
+            byHex.AddTypeDecoder<BaseVoid>(PhaseState.Initialization);
+            byHex.Create("0x0001");
+
+            Assert.That(byValue.Bytes, Is.EqualTo(byArray.Bytes));
+            Assert.That(byValue.Value, Is.EqualTo(byArray.Value));
+
+            Assert.That(byValue.Bytes, Is.EqualTo(byHex.Bytes));
+            Assert.That(byValue.Value, Is.EqualTo(byHex.Value));
+        }
+    }
+}

Substrate.NetApi.Test/TypeConverters/TupleRustTest.cs

@@ -0,0 +1,97 @@
+using NUnit.Framework;
+using Substrate.NetApi.Model.Types.Base;
+using Substrate.NetApi.Model.Types.Primitive;
+using System;
+using System.Collections.Generic;
+
+namespace Substrate.NetApi.Tests
+{
+    [TestFixture]
+    public class BaseTupleTests
+    {
+        [Test]
+        public void BaseTupleTest()
+        {
+            var u16Param = new U16(42);
+
+            var t1 = new BaseTupleRust(typeof(U16));
+            t1.Create("0x2a00");
+
+            Assert.AreEqual(1, t1.Value.Length);
+            Assert.AreEqual(t1.Bytes, new BaseTupleRust(new U16(42)).Bytes);
+            Assert.AreEqual(((U16)t1.Value[0]).Value, ((U16)new BaseTupleRust(new U16(42)).Value[0]).Value);
+            Assert.AreEqual(t1.TypeSize, new BaseTupleRust(new U16(42)).TypeSize);
+
+            var t2 = new BaseTupleRust(typeof(U16), typeof(U16));
+            t2.Create("0x2a002a00");
+            Assert.AreEqual(2, t2.Value.Length);
+            Assert.AreEqual(t2.Bytes, new BaseTupleRust(new U16(42), new U16(42)).Bytes);
+            Assert.AreEqual(((U16)t2.Value[0]).Value, ((U16)new BaseTupleRust(new U16(42), new U16(42)).Value[0]).Value);
+            Assert.AreEqual(((U16)t2.Value[1]).Value, ((U16)new BaseTupleRust(new U16(42), new U16(42)).Value[1]).Value);
+            Assert.AreEqual(t2.TypeSize, new BaseTupleRust(new U16(42), new U16(42)).TypeSize);
+
+            var t3 = new BaseTupleRust(typeof(U16), typeof(U16), typeof(U16));
+            t3.Create("0x2a002a002a00");
+            Assert.AreEqual(3, t3.Value.Length);
+            Assert.AreEqual(t3.Bytes, new BaseTupleRust(new U16(42), new U16(42), new U16(42)).Bytes);
+            Assert.AreEqual(((U16)t3.Value[0]).Value, ((U16)new BaseTupleRust(new U16(42), new U16(42), new U16(42)).Value[0]).Value);
+            Assert.AreEqual(((U16)t3.Value[1]).Value, ((U16)new BaseTupleRust(new U16(42), new U16(42), new U16(42)).Value[1]).Value);
+            Assert.AreEqual(((U16)t3.Value[2]).Value, ((U16)new BaseTupleRust(new U16(42), new U16(42), new U16(42)).Value[2]).Value);
+            Assert.AreEqual(t3.TypeSize, new BaseTupleRust(new U16(42), new U16(42), new U16(42)).TypeSize);
+        }
+
+        [Test]
+        public void BaseTupleCreateTest()
+        {
+            var u16 = new U16();
+            u16.Create("0x2a00");
+
+            var u32 = new U32();
+            u32.Create("0xffffff00");
+
+            var tupleOfTwo_1 = new BaseTupleRust(u16, u32);
+            Assert.AreEqual("0x2A00FFFFFF00", Utils.Bytes2HexString(tupleOfTwo_1.Encode()));
+            Assert.AreEqual(tupleOfTwo_1.Value.Length, new BaseTupleRust(u16, u32).Value.Length);
+            Assert.AreEqual(tupleOfTwo_1.Bytes, new BaseTupleRust(u16, u32).Bytes);
+            Assert.AreEqual(((U16)tupleOfTwo_1.Value[0]).Value, ((U16)new BaseTupleRust(u16, u32).Value[0]).Value);
+            Assert.AreEqual(((U32)tupleOfTwo_1.Value[1]).Value, ((U32)new BaseTupleRust(u16, u32).Value[1]).Value);
+
+            var tupleOfTwo_2 = new BaseTupleRust(typeof(U16), typeof(U32));
+            tupleOfTwo_2.Create("0x2A00FFFFFF00");
+
+            Assert.AreEqual(u16.Value, ((U16)tupleOfTwo_2.Value[0]).Value);
+            Assert.AreEqual(u32.Value, ((U32)tupleOfTwo_2.Value[1]).Value);
+
+            Assert.AreEqual(tupleOfTwo_1.Value.Length, tupleOfTwo_2.Value.Length);
+            Assert.AreEqual(tupleOfTwo_1.Bytes, tupleOfTwo_2.Bytes);
+            Assert.AreEqual(((U16)tupleOfTwo_1.Value[0]).Value, ((U16)tupleOfTwo_2.Value[0]).Value);
+            Assert.AreEqual(((U32)tupleOfTwo_1.Value[1]).Value, ((U32)tupleOfTwo_2.Value[1]).Value);
+        }
+
+        [Test]
+        public void BaseTypeEqualityWithNullBytes()
+        {
+            var baseTuple_1 = new BaseTupleRust(typeof(U32), typeof(U32));
+            var baseTuple_2 = new BaseTupleRust(typeof(U32), typeof(U32));
+            Assert.That(baseTuple_1.Bytes, Is.Null);
+            Assert.That(baseTuple_1.Value, Is.Null);
+            Assert.AreEqual(baseTuple_1.Bytes, baseTuple_2.Bytes);
+            Assert.AreEqual(baseTuple_1.Value, baseTuple_2.Value);
+
+            var baseOpt_1 = new BaseOpt<U32>();
+            var baseOpt_2 = new BaseOpt<U32>();
+            Assert.That(baseOpt_1.Bytes, Is.Null);
+            Assert.That(baseOpt_1.Value, Is.Null);
+            Assert.AreEqual(baseOpt_1.Bytes, baseOpt_2.Bytes);
+            Assert.AreEqual(baseOpt_1.Value, baseOpt_2.Value);
+
+            var baseVec_1 = new BaseVec<U32>();
+            var baseVec_2 = new BaseVec<U32>();
+            Assert.That(baseVec_1.Bytes, Is.Null);
+            Assert.That(baseVec_1.Value, Is.Null);
+            Assert.AreEqual(baseVec_1.Bytes, baseVec_2.Bytes);
+            Assert.AreEqual(baseVec_1.Value, baseVec_2.Value);
+        }
+    }
+
+}

Substrate.NetApi.Test/TypeConverters/TypeEncodingTest.cs

@@ -112,7 +112,7 @@ public enum PhaseState
         [Test]
         public void ExtEnumEncodingTest()
         {
-            var extEnumType = new BaseEnumExt<PhaseState, U8, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid>();
+            var extEnumType = new BaseEnumExt<PhaseState, U8, BaseVoid, BaseVoid>();
 
             int p = 0;
             extEnumType.Decode(new byte[] { 0x00, 0x01 }, ref p);
@@ -125,7 +125,7 @@ public void ExtEnumEncodingTest()
         [Test]
         public void ExtEnumDencodingTest()
         {
-            var extEnumType = new BaseEnumExt<PhaseState, U8, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid, BaseVoid>();
+            var extEnumType = new BaseEnumExt<PhaseState, U8, BaseVoid, BaseVoid>();
 
             int p = 0;
             extEnumType.Decode(new byte[] { 0x00, 0x01 }, ref p);

Substrate.NetApi/Model/Types/Base/BaseEnumRust.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+
+namespace Substrate.NetApi.Model.Types.Base
+{
+    /// <summary>
+    /// Next version of BaseEnumExt to support Rust enums
+    /// </summary>
+    /// <typeparam name="TEnum"></typeparam>
+    public class BaseEnumRust<TEnum> : BaseType where TEnum : Enum
+    {
+        private readonly Dictionary<TEnum, Func<byte[], int, Tuple<IType, int>>> _typeDecoders;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public BaseEnumRust()
+        {
+            _typeDecoders = new Dictionary<TEnum, Func<byte[], int, Tuple<IType, int>>>();
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public BaseEnumRust(Dictionary<TEnum, Type> typeDecoderMap)
+        {
+            _typeDecoders = new Dictionary<TEnum, Func<byte[], int, Tuple<IType, int>>>();
+            foreach (var decoder in typeDecoderMap)
+            {
+                var enumValue = decoder.Key;
+                var type = decoder.Value;
+
+                _typeDecoders.Add(enumValue, (byteArray, p) =>
+                {
+                    var typeInstance = (IType)Activator.CreateInstance(type);
+                    typeInstance.Decode(byteArray, ref p);
+                    return new Tuple<IType, int>(typeInstance, p);
+                });
+            }
+        }
+
+        /// <summary>
+        /// Add a type decoder
+        /// </summary>
+        /// <typeparam name="TType"></typeparam>
+        /// <param name="enumValue"></param>
+        public void AddTypeDecoder<TType>(TEnum enumValue) where TType : IType, new()
+        {
+            _typeDecoders.Add(enumValue, (byteArray, p) =>
+            {
+                var typeInstance = new TType();
+                typeInstance.Decode(byteArray, ref p);
+                return new Tuple<IType, int>(typeInstance, p);
+            });
+        }
+
+        /// <inheritdoc/>
+        public override void Decode(byte[] byteArray, ref int p)
+        {
+            var start = p;
+            var enumByte = byteArray[p];
+            p += 1;
+
+            try
+            {
+                Value = (TEnum)Enum.Parse(typeof(TEnum), enumByte.ToString(), true);
+            }
+            catch (ArgumentException ex)
+            {
+                throw new Exception($"Invalid enum value: {enumByte}", ex);
+            }
+
+            if (_typeDecoders.TryGetValue(Value, out var decoder))
+            {
+                var result = decoder(byteArray, p);
+                Value2 = result.Item1;
+                p = result.Item2;
+            } 
+            else
+            {
+               throw new Exception($"No decoder found for enum byte {enumByte}");
+            }
+
+            TypeSize = p - start;
+            Bytes = new byte[TypeSize];
+            Array.Copy(byteArray, start, Bytes, 0, TypeSize);
+        }
+
+        /// <inheritdoc/>
+        public override byte[] Encode()
+        {
+            return Bytes;
+        }
+
+        /// <summary>
+        /// Create from enum and it's value
+        /// </summary>
+        /// <param name="t"></param>
+        /// <param name="iType"></param>
+        public void Create(TEnum t, IType iType)
+        {
+            var enumByte = Convert.ToByte(t);
+
+            if (!_typeDecoders.ContainsKey(t))
+            {
+                throw new Exception($"No decoder found for enum byte {enumByte}, make sure to use BaseVoid, if there is no value.");
+            }
+
+            Value = t;
+            Value2 = iType;
+
+            // Encode the enum byte and IType
+            var bytes = new List<byte> { enumByte };
+            bytes.AddRange(iType.Encode());
+            Bytes = bytes.ToArray();
+        }
+
+        /// <inheritdoc/>
+        public TEnum Value { get; set; }
+        /// <inheritdoc/>
+        public IType Value2 { get; set; }
+    }
+}