fix Bug : non first position discriminator is not supported #29

Author: Michael Catanzariti

src/Dahomey.Cbor.Tests/Issues/Issue0029.cs

@@ -0,0 +1,30 @@
+using Dahomey.Cbor.Attributes;
+using Xunit;
+
+namespace Dahomey.Cbor.Tests.Issues
+{
+    public class Issue0029
+    {
+        public abstract class DummyParticle
+        {
+
+        }
+
+        [CborDiscriminator("radix.particles.message", Policy = CborDiscriminatorPolicy.Always)]
+        public class DummyMessageParticle : DummyParticle
+        {
+            public long nonce { get; protected set; }
+        }
+
+        [Fact]
+        public void Test()
+        {
+            CborOptions options = new CborOptions();
+            options.Registry.DefaultDiscriminatorConvention.RegisterAssembly(typeof(DummyParticle).Assembly);
+
+            // {"nonce": 2181035975144481159, "_t": "radix.particles.message"}
+            const string hexBuffer = "A2656E6F6E63651B1E4498A9ECD5A187625F747772616469782E7061727469636C65732E6D657373616765";
+            DummyParticle obj = Helper.Read<DummyParticle>(hexBuffer, options);
+        }
+    }
+}

src/Dahomey.Cbor/Serialization/CborReader.cs

@@ -34,35 +34,45 @@ public interface ICborArrayReader<TC>
         void ReadArrayItem(ref CborReader reader, ref TC context);
     }
 
-    public ref struct CborReader
+    public enum CborReaderState
     {
-        private enum State
-        {
-            Start,
-            Header,
-            Data
-        }
+        Start,
+        Header,
+        Data
+    }
 
-        [StructLayout(LayoutKind.Explicit, Size = 2)]
-        private struct Header
-        {
-            [FieldOffset(0)]
-            public CborMajorType MajorType;
+    [StructLayout(LayoutKind.Explicit, Size = 2)]
+    public struct CborReaderHeader
+    {
+        [FieldOffset(0)]
+        public CborMajorType MajorType;
 
-            [FieldOffset(1)]
-            public byte AdditionalValue;
+        [FieldOffset(1)]
+        public byte AdditionalValue;
 
-            [FieldOffset(1)]
-            public CborPrimitive Primitive;
-        }
+        [FieldOffset(1)]
+        public CborPrimitive Primitive;
+    }
 
+    public ref struct CborReaderBookmark
+    {
+        public ReadOnlySpan<byte> buffer;
+        public int currentPos;
+        public CborReaderState state;
+        public CborReaderHeader header;
+        public int remainingItemCount;
+    }
+
+    public ref struct CborReader
+    {
         private const int CHUNK_SIZE = 1024;
         private const byte INDEFINITE_LENGTH = 31;
 
         private ReadOnlySpan<byte> _buffer;
         private int _currentPos;
-        private State _state;
-        private Header _header;
+        private CborReaderState _state;
+        private CborReaderHeader _header;
+        private int _remainingItemCount;
 
         public CborOptions Options { get; }
 
@@ -71,8 +81,9 @@ public CborReader(ReadOnlySpan<byte> buffer, CborOptions options = null)
             _buffer = buffer;
             Options = options ?? CborOptions.Default;
             _currentPos = 0;
-            _state = State.Start;
-            _header = new Header();
+            _state = CborReaderState.Start;
+            _header = new CborReaderHeader();
+            _remainingItemCount = 0;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -81,7 +92,7 @@ public bool TryReadSemanticTag(out ulong semanticTag)
             if (Accept(CborMajorType.SemanticTag))
             {
                 semanticTag = ReadInteger();
-                _state = State.Data;
+                _state = CborReaderState.Data;
                 return true;
             }
 
@@ -93,7 +104,7 @@ public bool TryReadSemanticTag(out ulong semanticTag)
         public CborDataItemType GetCurrentDataItemType()
         {
             SkipSemanticTag();
-            Header header = GetHeader();
+            CborReaderHeader header = GetHeader();
 
             switch (header.MajorType)
             {
@@ -149,6 +160,28 @@ public CborDataItemType GetCurrentDataItemType()
             }
         }
 
+        public CborReaderBookmark GetBookmark()
+        {
+            CborReaderBookmark bookmark;
+
+            bookmark.buffer = _buffer;
+            bookmark.currentPos = _currentPos;
+            bookmark.state = _state;
+            bookmark.header = _header;
+            bookmark.remainingItemCount = _remainingItemCount;
+
+            return bookmark;
+        }
+
+        public void ReturnToBookmark(CborReaderBookmark bookmark)
+        {
+            _buffer = bookmark.buffer;
+            _currentPos = bookmark.currentPos;
+            _state = bookmark.state;
+            _header = bookmark.header;
+            _remainingItemCount = bookmark.remainingItemCount;
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadBeginArray()
         {
@@ -316,7 +349,7 @@ public int ReadSize()
         {
             if (GetHeader().AdditionalValue == INDEFINITE_LENGTH)
             {
-                _state = State.Data;
+                _state = CborReaderState.Data;
                 return -1;
             }
 
@@ -328,17 +361,29 @@ public void ReadMap<TC>(ICborMapReader<TC> mapReader, ref TC context)
         {
             ReadBeginMap();
 
-            int size = ReadSize();
+            int previousRemainingItemCount = _remainingItemCount;
+            _remainingItemCount = ReadSize();
 
-            mapReader.ReadBeginMap(size, ref context);
+            mapReader.ReadBeginMap(_remainingItemCount, ref context);
 
-            while (size > 0 || size < 0 && GetCurrentDataItemType() != CborDataItemType.Break)
+            while (MoveNextMapItem())
             {
                 mapReader.ReadMapItem(ref this, ref context);
-                size--;
             }
 
-            _state = State.Start;
+            _state = CborReaderState.Start;
+            _remainingItemCount = previousRemainingItemCount;
+        }
+
+        public bool MoveNextMapItem()
+        {
+            if (_remainingItemCount == 0 || _remainingItemCount < 0 && GetCurrentDataItemType() == CborDataItemType.Break)
+            {
+                return false;
+            }
+
+            _remainingItemCount--;
+            return true;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -356,13 +401,13 @@ public void ReadArray<TC>(ICborArrayReader<TC> arrayReader, ref TC context)
                 size--;
             }
 
-            _state = State.Start;
+            _state = CborReaderState.Start;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private ulong ReadUnsigned(ulong maxValue)
         {
-            Header header = GetHeader();
+            CborReaderHeader header = GetHeader();
 
             switch (header.MajorType)
             {
@@ -377,7 +422,7 @@ private ulong ReadUnsigned(ulong maxValue)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private long ReadSigned(long maxValue)
         {
-            Header header = GetHeader();
+            CborReaderHeader header = GetHeader();
 
             switch (header.MajorType)
             {
@@ -395,7 +440,7 @@ private long ReadSigned(long maxValue)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private ulong ReadInteger(ulong maxValue = ulong.MaxValue)
         {
-            Header header = GetHeader();
+            CborReaderHeader header = GetHeader();
 
             ulong value;
 
@@ -429,7 +474,7 @@ private ulong ReadInteger(ulong maxValue = ulong.MaxValue)
 
                 default:
                     value = header.AdditionalValue;
-                    _state = State.Data;
+                    _state = CborReaderState.Data;
                     break;
             }
 
@@ -517,9 +562,9 @@ private ReadOnlySpan<byte> ReadSizeAndBytes()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private Header GetHeader()
+        private CborReaderHeader GetHeader()
         {
-            if (_state == State.Header)
+            if (_state == CborReaderState.Header)
             {
                 return _header;
             }
@@ -535,7 +580,7 @@ private Header GetHeader()
             }
 
             Advance();
-            _state = State.Header;
+            _state = CborReaderState.Header;
 
             return _header;
         }
@@ -570,15 +615,15 @@ private void SkipSemanticTag()
             if (Accept(CborMajorType.SemanticTag))
             {
                 ReadInteger();
-                _state = State.Data;
+                _state = CborReaderState.Data;
                 return;
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SkipDataItem()
         {
-            Header header = GetHeader();
+            CborReaderHeader header = GetHeader();
 
             switch (header.MajorType)
             {
@@ -601,7 +646,7 @@ public void SkipDataItem()
                     break;
 
                 case CborMajorType.SemanticTag:
-                    _state = State.Data;
+                    _state = CborReaderState.Data;
                     break;
 
                 case CborMajorType.Primitive:
@@ -613,7 +658,7 @@ public void SkipDataItem()
                         case CborPrimitive.Undefined:
                         case CborPrimitive.SimpleValue:
                         case CborPrimitive.Break:
-                            _state = State.Data;
+                            _state = CborReaderState.Data;
                             break;
 
                         case CborPrimitive.HalfFloat:
@@ -643,7 +688,7 @@ private void SkipArray()
                 size--;
             }
 
-            _state = State.Start;
+            _state = CborReaderState.Start;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -658,15 +703,15 @@ private void SkipMap()
                 size--;
             }
 
-            _state = State.Start;
+            _state = CborReaderState.Start;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private bool Accept(CborPrimitive primitive)
         {
             if (Accept(CborMajorType.Primitive) && _header.Primitive == primitive)
             {
-                _state = State.Data;
+                _state = CborReaderState.Data;
                 return true;
             }
 
@@ -709,9 +754,9 @@ private void ExpectLength(int length)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void Advance(int length = 1)
         {
-            if (_state == State.Header)
+            if (_state == CborReaderState.Header)
             {
-                _state = State.Data;
+                _state = CborReaderState.Data;
             }
             _buffer = _buffer.Slice(length);
             _currentPos += length;

src/Dahomey.Cbor/Serialization/Conventions/DefaultDiscriminatorConvention.cs

@@ -13,6 +13,7 @@ public class DefaultDiscriminatorConvention : IDiscriminatorConvention
         private readonly ReadOnlyMemory<byte> _memberName = Encoding.ASCII.GetBytes("_t");
         private readonly ByteBufferDictionary<Type> _typesByDiscriminator = new ByteBufferDictionary<Type>();
         private readonly Dictionary<Type, ReadOnlyMemory<byte>> _discriminatorsByType = new Dictionary<Type, ReadOnlyMemory<byte>>();
+        private readonly HashSet<Type> _discriminatedTypes = new HashSet<Type>();
 
         public ReadOnlySpan<byte> MemberName => _memberName.Span;
 
@@ -38,6 +39,16 @@ public void WriteDiscriminator<T>(ref CborWriter writer, Type actualType)
             writer.WriteString(discriminator.Span);
         }
 
+        /// <summary>
+        /// Returns whether the given type has any discriminators registered for any of its subclasses.
+        /// </summary>
+        /// <param name="type">A Type.</param>
+        /// <returns>True if the type is discriminated.</returns>
+        public bool IsTypeDiscriminated(Type type)
+        {
+            return type.IsInterface || _discriminatedTypes.Contains(type);
+        }
+
         public void RegisterAssembly(Assembly assembly)
         {
             foreach (Type type in assembly.GetTypes()
@@ -52,6 +63,12 @@ public void RegisterType(Type type, ReadOnlyMemory<byte> discriminator)
         {
             _typesByDiscriminator.Add(discriminator.Span, type);
             _discriminatorsByType[type] = discriminator;
+
+            // mark all base types as discriminated (so we know that it's worth reading a discriminator)
+            for (Type baseType = type.BaseType; baseType != null; baseType = baseType.BaseType)
+            {
+                _discriminatedTypes.Add(baseType);
+            }
         }
     }
 }

src/Dahomey.Cbor/Serialization/Conventions/IDiscriminatorConvention.cs

@@ -1,5 +1,4 @@
-using Dahomey.Cbor.Serialization.Converters;
-using System;
+using System;
 
 namespace Dahomey.Cbor.Serialization.Conventions
 {
@@ -8,5 +7,6 @@ public interface IDiscriminatorConvention
         ReadOnlySpan<byte> MemberName { get; }
         Type ReadDiscriminator(ref CborReader reader);
         void WriteDiscriminator<T>(ref CborWriter writer, Type actualType) where T : class;
+        bool IsTypeDiscriminated(Type type);
     }
 }