using System;

using System.IO;

using System.Collections.Generic;

using YamlDotNet.Serialization;

using YamlDotNet.Core;

using YamlDotNet.Core.Events;

​

namespace YamlDotNet.Samples

{

    public class Program

    {

        public void Main()

        {

            var deserializer = new Deserializer();

            deserializer.RegisterTagMapping("tag:yaml.org,2002:set", typeof(YamlSet<object>));

            var set = deserializer.Deserialize(new StringReader(@"

!!set

    ? DDMMYYYY: 25/12/2042

      MMDDYYYY: 12/25/2042

      date:

        chronology: &id001

          calendarType: iso8601

          id: ISO

        dayOfMonth: 25

        dayOfWeek: THURSDAY

        dayOfYear: 359

        era: CE

        leapYear: false

        month: DECEMBER

        monthValue: 12

        year: 2042

      serialValue: 52225

    : null

"));

            foreach(var value in (YamlSet<object>)set) {

                Console.WriteLine(value);

            }

        }

    }

​

    public class YamlSet<T> : HashSet<T>, IDictionary<T, object>

    {

        void IDictionary<T, object>.Add(T key, object value)

        {

            Add(key);

        }

​

        bool IDictionary<T, object>.ContainsKey(T key)

        {

            throw new NotImplementedException();

        }

​

        ICollection<T> IDictionary<T, object>.Keys

        {

            get { throw new NotImplementedException(); }

        }

​

        bool IDictionary<T, object>.Remove(T key)

        {

            throw new NotImplementedException();

        }

​

        bool IDictionary<T, object>.TryGetValue(T key, out object value)

        {

            throw new NotImplementedException();

        }

​

        ICollection<object> IDictionary<T, object>.Values

        {

            get { throw new NotImplementedException(); }

        }

​

        object IDictionary<T, object>.this[T key]

        {

            get

            {

                throw new NotImplementedException();

            }

            set

            {

                Add(key);

            }

        }

​

        void ICollection<KeyValuePair<T, object>>.Add(KeyValuePair<T, object> item)

        {

            throw new NotImplementedException();

        }

​

        void ICollection<KeyValuePair<T, object>>.Clear()

        {

            throw new NotImplementedException();

        }

​

        bool ICollection<KeyValuePair<T, object>>.Contains(KeyValuePair<T, object> item)

        {

            throw new NotImplementedException();

        }

​

        void ICollection<KeyValuePair<T, object>>.CopyTo(KeyValuePair<T, object>[] array, int arrayIndex)

        {

            throw new NotImplementedException();

        }

​

        int ICollection<KeyValuePair<T, object>>.Count

        {

            get { throw new NotImplementedException(); }

        }

​

        bool ICollection<KeyValuePair<T, object>>.IsReadOnly

        {

            get { throw new NotImplementedException(); }

        }

​

        bool ICollection<KeyValuePair<T, object>>.Remove(KeyValuePair<T, object> item)

        {

            throw new NotImplementedException();

        }

​

        IEnumerator<KeyValuePair<T, object>> IEnumerable<KeyValuePair<T, object>>.GetEnumerator()

        {

            throw new NotImplementedException();

        }

​

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            throw new NotImplementedException();

        }

    }   

​

    public class FloatNodeDeserializer : INodeDeserializer

    {

        private static readonly Dictionary<Tuple<Type, string>, object> SpecialFloats = new Dictionary<Tuple<Type, string>, object>

        {

            { Tuple.Create(typeof(float), ".nan"), float.NaN },

            { Tuple.Create(typeof(float), ".inf"), float.PositiveInfinity },

            { Tuple.Create(typeof(float), "-.inf"), float.NegativeInfinity },

​

            { Tuple.Create(typeof(double), ".nan"), double.NaN },

            { Tuple.Create(typeof(double), ".inf"), double.PositiveInfinity },

            { Tuple.Create(typeof(double), "-.inf"), double.NegativeInfinity },

        };

        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)

        {

            var scalar = reader.Peek<Scalar>();

            if (scalar == null)

            {

                value = null;

                return false;

            }

            var found = SpecialFloats.TryGetValue(Tuple.Create(expectedType, scalar.Value), out value);

            if(found)

            {

                reader.Allow<Scalar>();

            }

            return found;

        }

    }

}