jellyfin/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/ConcurrentHashMap.cs

using System.Collections.Generic;

namespace SharpCifs.Util.Sharpen
{
    internal class ConcurrentHashMap<T, TU> : AbstractMap<T, TU>, IConcurrentMap<T, TU>
	{
		private Dictionary<T, TU> _table;

		public ConcurrentHashMap ()
		{
			_table = new Dictionary<T, TU> ();
		}

		public ConcurrentHashMap (int initialCapacity, float loadFactor, int concurrencyLevel)
		{
			_table = new Dictionary<T, TU> (initialCapacity);
		}

		public override void Clear ()
		{
			lock (_table) {
				_table = new Dictionary<T, TU> ();
			}
		}

		public override bool ContainsKey (object name)
		{
			return _table.ContainsKey ((T)name);
		}

		public override ICollection<KeyValuePair<T, TU>> EntrySet ()
		{
			return this;
		}

		public override TU Get (object key)
		{
			TU local;
			_table.TryGetValue ((T)key, out local);
			return local;
		}

		protected override IEnumerator<KeyValuePair<T, TU>> InternalGetEnumerator ()
		{
			return _table.GetEnumerator ();
		}

		public override bool IsEmpty ()
		{
			return _table.Count == 0;
		}

		public override TU Put (T key, TU value)
		{
			lock (_table) {
				TU old = Get (key);
				Dictionary<T, TU> newTable = new Dictionary<T, TU> (_table);
				newTable[key] = value;
				_table = newTable;
				return old;
			}
		}

		public TU PutIfAbsent (T key, TU value)
		{
			lock (_table) {
				if (!ContainsKey (key)) {
					Dictionary<T, TU> newTable = new Dictionary<T, TU> (_table);
					newTable[key] = value;
					_table = newTable;
					return value;
				}
				return Get (key);
			}
		}

		public override TU Remove (object key)
		{
			lock (_table) {
				TU old = Get ((T)key);
				Dictionary<T, TU> newTable = new Dictionary<T, TU> (_table);
				newTable.Remove ((T)key);
				_table = newTable;
				return old;
			}
		}

		public bool Remove (object key, object value)
		{
			lock (_table) {
				if (ContainsKey (key) && value.Equals (Get (key))) {
					Dictionary<T, TU> newTable = new Dictionary<T, TU> (_table);
					newTable.Remove ((T)key);
					_table = newTable;
					return true;
				}
				return false;
			}
		}

		public bool Replace (T key, TU oldValue, TU newValue)
		{
			lock (_table) {
				if (ContainsKey (key) && oldValue.Equals (Get (key))) {
					Dictionary<T, TU> newTable = new Dictionary<T, TU> (_table);
					newTable[key] = newValue;
					_table = newTable;
					return true;
				}
				return false;
			}
		}

		public override IEnumerable<T> Keys {
			get { return _table.Keys; }
		}

		public override IEnumerable<TU> Values {
			get { return _table.Values; }
		}
	}
}