MultiDictionary.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace Mercury.Nucleus.Collections
{
//=============================================================================
//  IReadOnlyMultiDictionary
//=============================================================================

    public interface IReadOnlyMultiDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
    {
        bool Contains(TKey key, TValue value);

        bool ContainsKey(TKey key);

        bool TryGetValue(TKey key, out IReadOnlyList<TValue> collection);

        ICollection<TKey> Keys { get; }

        IReadOnlyList<TValue> this[TKey key] { get; }
    }

//=============================================================================
//  IMultiDictionary
//=============================================================================

    public interface IMultiDictionary<TKey, TValue> : IReadOnlyMultiDictionary<TKey, TValue>
    {
        bool Add(TKey key, TValue value);

        bool Add(KeyValuePair<TKey, TValue> tuple);

        bool Add(TKey key, IEnumerable<TValue> values);

        void Clear();
    }

//=============================================================================
//  SetMultiDictionary
//=============================================================================

    public class SetMultiDictionary<TKey, TValue> :
        IMultiDictionary<TKey, TValue>
    {
        //--[  Protected fields  ]---------------------------------------------

        protected Dictionary<TKey, HashSet<TValue>> data
            = new Dictionary<TKey, HashSet<TValue>>();

        //--[  Interface implementation  ]-------------------------------------

        #region [  IMultiDictionary  ]

        public bool Add(TKey key, TValue value)
        {
            HashSet<TValue> set;
            if (data.TryGetValue(key, out set))
                return set.Add(value);

            data.Add(key, new HashSet<TValue> { value });
            return true;
        }

        public bool Add(KeyValuePair<TKey, TValue> pair)
        { return this.Add(pair.Key, pair.Value); }

        public bool Add(TKey key, IEnumerable<TValue> values)
        {
            if (data.ContainsKey(key)) return false;

            data.Add(key, new HashSet<TValue>(values));
            return true;
        }

        public bool Contains(TKey key, TValue value)
        {
            HashSet<TValue> set;
            if (!data.TryGetValue(key, out set))
                return false;

            return set.Contains(value);
        }

        public bool ContainsKey(TKey key)
        { return data.ContainsKey(key); }

        public void Clear()
        { data.Clear(); }

        public bool TryGetValue(TKey key, out IReadOnlyList<TValue> collection)
        {
            if (key == null) throw new ArgumentNullException("key");

            HashSet<TValue> values = null;
            bool r = data.TryGetValue(key, out values);
            collection = values.ToList();
            return r;
        }

        public ICollection<TKey> Keys { get { return data.Keys; } }

        public IReadOnlyList<TValue> this[TKey key]
        { get { return data[key].ToList(); } }

        #endregion

        #region [  IEnumerable       ]

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            foreach(var pair in data)
                foreach (var value in pair.Value)
                    yield return new KeyValuePair<TKey, TValue>(pair.Key, value);
        }

        IEnumerator IEnumerable.GetEnumerator()
        { return GetEnumerator() as IEnumerator; }

        #endregion

    }

//=============================================================================
//  ListMultiDictionary
//=============================================================================

    public class ListMultiDictionary<TKey, TValue> :
        IMultiDictionary<TKey, TValue>
    {
        //--[  Protected fields  ]---------------------------------------------

        private Dictionary<TKey, List<TValue>> data
            = new Dictionary<TKey, List<TValue>>();

        //--[  Constructors  ]-------------------------------------------------

        public ListMultiDictionary()
        { }

        public ListMultiDictionary(IMultiDictionary<TKey, TValue> source)
        { foreach(var pair in source) Add(pair.Key, pair.Value); }

        //--[  Methods  ]------------------------------------------------------

        public TValue GetValue(TKey key, int ix)
        { return data[key][ix]; }

        public int GetValuesCount(TKey key)
        { return data[key].Count; }

        //--[  Interface implementation  ]-------------------------------------

        #region [  IMultiDictionary  ]

        public virtual bool Add(TKey key, TValue value)
        {
            List<TValue> values = null;
            if (data.TryGetValue(key, out values))
                values.Add(value);
            else
                data.Add(key, new List<TValue> { value });

            return true;
        }

        public virtual bool Add(KeyValuePair<TKey, TValue> pair)
        { return this.Add(pair.Key, pair.Value); }

        public virtual bool Add(TKey key, IEnumerable<TValue> values)
        {
            if (data.ContainsKey(key)) return false;

            data.Add(key, new List<TValue>(values));
            return true;
        }

        public virtual bool Contains(TKey key, TValue value)
        {
            List<TValue> list;
            if (!data.TryGetValue(key, out list))
                return false;

            return list.Contains(value);
        }

        public bool ContainsKey(TKey key)
        { return data.ContainsKey(key); }

        public virtual void Clear() 
        { data.Clear(); }

        public bool TryGetValue(TKey key, out IReadOnlyList<TValue> collection)
        {
            if (key == null) throw new ArgumentNullException("key");

            List<TValue> values = null;
            bool r = data.TryGetValue(key, out values);
            collection = values;
            return r;
        }

        public ICollection<TKey> Keys { get { return data.Keys; } }

        public IReadOnlyList<TValue> this[TKey key]
        { get { return data[key]; } }

        #endregion

        #region [  IEnumerable       ]

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            foreach(var pair in data)
                for (int ix = 0; ix < pair.Value.Count; ++ix)
                    yield return new KeyValuePair<TKey, TValue>(pair.Key, pair.Value[ix]);
        }

        IEnumerator IEnumerable.GetEnumerator()
        { return GetEnumerator() as IEnumerator; }

        #endregion

    }

//=============================================================================
//  UniqueListMultiDictionary
//=============================================================================

    public class UniqueListMultiDictionary<TKey, TValue> :
        ListMultiDictionary<TKey, TValue>, IMultiDictionary<TKey, TValue>
    {
        //--[  Protected fields  ]---------------------------------------------

        protected SetMultiDictionary<TKey, TValue> data
            = new SetMultiDictionary<TKey, TValue>();

        //--[  Overriden methods  ]--------------------------------------------

        #region [  ListMultiDictionary  ]

        public override bool Add(TKey key, TValue value)
        { return data.Add(key, value) && base.Add(key, value); }

        public override bool Contains(TKey key, TValue value)
        { return data.Contains(key, value); }

        public override void Clear()
        { data.Clear(); base.Clear(); }

        #endregion

    }
}