merge common implementations and server implementations

2026-04-30 13:56:31 +01:00 · 2017-08-16 02:43:41 -04:00
parent e3531534b8
commit bfcd1b520f
389 changed files with 1212 additions and 1626 deletions
--- a/Emby.Server.Implementations/IO/SharpCifs/Util/Sharpen/AbstractMap.cs
+++ b/Emby.Server.Implementations/IO/SharpCifs/Util/Sharpen/AbstractMap.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SharpCifs.Util.Sharpen
+{
+    public abstract class AbstractMap<T, TU> : IDictionary<T, TU>
+	{
+	    public virtual void Clear ()
+		{
+			EntrySet ().Clear ();
+		}
+
+		public virtual bool ContainsKey (object name)
+		{
+			return EntrySet ().Any (p => p.Key.Equals ((T)name));
+		}
+
+		public abstract ICollection<KeyValuePair<T, TU>> EntrySet ();
+
+		public virtual TU Get (object key)
+		{
+			return EntrySet ().Where (p => p.Key.Equals (key)).Select (p => p.Value).FirstOrDefault ();
+		}
+
+		protected virtual IEnumerator<KeyValuePair<T, TU>> InternalGetEnumerator ()
+		{
+			return EntrySet ().GetEnumerator ();
+		}
+
+		public virtual bool IsEmpty ()
+		{
+			return !EntrySet ().Any ();
+		}
+
+		public virtual TU Put (T key, TU value)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public virtual TU Remove (object key)
+		{
+			Iterator<TU> iterator = EntrySet () as Iterator<TU>;
+			if (iterator == null) {
+				throw new NotSupportedException ();
+			}
+			while (iterator.HasNext ()) {
+				TU local = iterator.Next ();
+				if (local.Equals ((T)key)) {
+					iterator.Remove ();
+					return local;
+				}
+			}
+			return default(TU);
+		}
+
+		void ICollection<KeyValuePair<T, TU>>.Add (KeyValuePair<T, TU> item)
+		{
+			Put (item.Key, item.Value);
+		}
+
+		bool ICollection<KeyValuePair<T, TU>>.Contains (KeyValuePair<T, TU> item)
+		{
+			throw new NotImplementedException ();
+		}
+
+		void ICollection<KeyValuePair<T, TU>>.CopyTo (KeyValuePair<T, TU>[] array, int arrayIndex)
+		{
+			EntrySet ().CopyTo (array, arrayIndex);
+		}
+
+		bool ICollection<KeyValuePair<T, TU>>.Remove (KeyValuePair<T, TU> item)
+		{
+			Remove (item.Key);
+			return true;
+		}
+
+		void IDictionary<T, TU>.Add (T key, TU value)
+		{
+			Put (key, value);
+		}
+
+		bool IDictionary<T, TU>.ContainsKey (T key)
+		{
+			return ContainsKey (key);
+		}
+
+		bool IDictionary<T, TU>.Remove (T key)
+		{
+			if (ContainsKey (key)) {
+				Remove (key);
+				return true;
+			}
+			return false;
+		}
+
+		bool IDictionary<T, TU>.TryGetValue (T key, out TU value)
+		{
+			if (ContainsKey (key)) {
+				value = Get (key);
+				return true;
+			}
+			value = default(TU);
+			return false;
+		}
+
+		IEnumerator<KeyValuePair<T, TU>> IEnumerable<KeyValuePair<T, TU>>.GetEnumerator ()
+		{
+			return InternalGetEnumerator ();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			return InternalGetEnumerator ();
+		}
+
+		public virtual int Count {
+			get { return EntrySet ().Count; }
+		}
+
+		public TU this[T key] {
+			get { return Get (key); }
+			set { Put (key, value); }
+		}
+
+		public virtual IEnumerable<T> Keys {
+			get { return EntrySet ().Select (p => p.Key); }
+		}
+
+		int ICollection<KeyValuePair<T, TU>>.Count {
+			get { return Count; }
+		}
+
+		bool ICollection<KeyValuePair<T, TU>>.IsReadOnly {
+			get { return false; }
+		}
+
+		ICollection<T> IDictionary<T, TU>.Keys {
+			get { return Keys.ToList (); }
+		}
+
+		ICollection<TU> IDictionary<T, TU>.Values {
+			get { return Values.ToList (); }
+		}
+
+		public virtual IEnumerable<TU> Values {
+			get { return EntrySet ().Select (p => p.Value); }
+		}
+	}
+}