Imported Upstream version 6.4.0.137

Former-commit-id: 943baa9f16a098c33e129777827f3a9d20da00d6

mcs/class/System.Private.CoreLib/System/MulticastDelegate.cs

@@ -0,0 +1,262 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Runtime.InteropServices;
+
+namespace System
+{
+	[StructLayout (LayoutKind.Sequential)]
+	public abstract class MulticastDelegate : Delegate
+	{
+		Delegate[]? delegates;
+
+		protected MulticastDelegate (object target, string method)
+			: base (target, method)
+		{
+		}
+
+		protected MulticastDelegate (Type target, string method)
+			: base (target, method)
+		{
+		}
+		
+		public override void GetObjectData (SerializationInfo info, StreamingContext context)
+		{
+			throw new SerializationException (SR.Serialization_DelegatesNotSupported);
+		}
+
+		protected sealed override object? DynamicInvokeImpl (object?[]? args)
+		{
+			if (delegates == null) {
+				return base.DynamicInvokeImpl (args);
+			} else {
+				object r;
+				int i = 0, len = delegates.Length;
+				do {
+					r = delegates [i].DynamicInvoke (args);
+				} while (++i < len);
+				return r;
+			}
+		}
+
+		// Some high-performance applications use this internal property
+		// to avoid using a slow path to determine if there is more than one handler
+		// This brings an API that we removed in f410e545e2db0e0dc338673a6b10a5cfd2d3340f
+		// which some users depeneded on
+		//
+		// This is an example of code that used this:
+		// https://gist.github.com/migueldeicaza/cd99938c2a4372e7e5d5
+		//
+		// Do not remove this API
+		internal bool HasSingleTarget {
+			get { return delegates == null; }
+		}
+
+		// <remarks>
+		//   Equals: two multicast delegates are equal if their base is equal
+		//   and their invocations list is equal.
+		// </remarks>
+		public sealed override bool Equals (object? obj)
+		{
+			if (!base.Equals (obj))
+				return false;
+
+			if (!(obj is MulticastDelegate d))
+				return false;
+
+			if (delegates == null && d.delegates == null) {
+				return true;
+			} else if (delegates == null ^ d.delegates == null) {
+				return false;
+			} else {
+				if (delegates.Length != d.delegates.Length)
+					return false;
+
+				for (int i = 0; i < delegates.Length; ++i) {
+					if (!delegates [i].Equals (d.delegates [i]))
+						return false;
+				}
+
+				return true;
+			}
+		}
+
+		//
+		// FIXME: This could use some improvements.
+		//
+		public sealed override int GetHashCode ()
+		{
+			return base.GetHashCode ();
+		}
+
+		protected override MethodInfo GetMethodImpl ()
+		{
+			if (delegates != null)
+				return delegates [delegates.Length - 1].Method;
+
+			return base.GetMethodImpl ();
+		}
+
+		// <summary>
+		//   Return, in order of invocation, the invocation list
+		//   of a MulticastDelegate
+		// </summary>
+		public sealed override Delegate[] GetInvocationList ()
+		{
+			if (delegates != null)
+				return (Delegate[]) delegates.Clone ();
+			else
+				return new Delegate[1] { this };
+		}
+
+		// <summary>
+		//   Combines this MulticastDelegate with the (Multicast)Delegate `follow'.
+		//   This does _not_ combine with Delegates. ECMA states the whole delegate
+		//   thing should have better been a simple System.Delegate class.
+		//   Compiler generated delegates are always MulticastDelegates.
+		// </summary>
+		protected sealed override Delegate CombineImpl (Delegate? follow)
+		{
+			if (follow == null)
+				return this;
+
+			MulticastDelegate other = (MulticastDelegate) follow;
+
+			MulticastDelegate ret = AllocDelegateLike_internal (this);
+
+			if (delegates == null && other.delegates == null) {
+				ret.delegates = new Delegate [2] { this, other };
+			} else if (delegates == null) {
+				ret.delegates = new Delegate [1 + other.delegates.Length];
+
+				ret.delegates [0] = this;
+				Array.Copy (other.delegates, 0, ret.delegates, 1, other.delegates.Length);
+			} else if (other.delegates == null) {
+				ret.delegates = new Delegate [delegates.Length + 1];
+
+				Array.Copy (delegates, 0, ret.delegates, 0, delegates.Length);
+				ret.delegates [ret.delegates.Length - 1] = other;
+			} else {
+				ret.delegates = new Delegate [delegates.Length + other.delegates.Length];
+
+				Array.Copy (delegates, 0, ret.delegates, 0, delegates.Length);
+				Array.Copy (other.delegates, 0, ret.delegates, delegates.Length, other.delegates.Length);
+			}
+
+			return ret;
+		}
+
+		/* Based on the Boyer–Moore string search algorithm */
+		int LastIndexOf (Delegate[] haystack, Delegate[] needle)
+		{
+			if (haystack.Length < needle.Length)
+				return -1;
+
+			if (haystack.Length == needle.Length) {
+				for (int i = 0; i < haystack.Length; ++i)
+					if (!haystack [i].Equals (needle [i]))
+						return -1;
+
+				return 0;
+			}
+
+			for (int i = haystack.Length - needle.Length, j; i >= 0;) {
+				for (j = 0; needle [j].Equals (haystack [i]); ++i, ++j) {
+					if (j == needle.Length - 1)
+						return i - j;
+				}
+
+				i -= j + 1;
+			}
+
+			return -1;
+		}
+
+		protected sealed override Delegate RemoveImpl (Delegate value)
+		{
+			if (value == null)
+				return this;
+
+			MulticastDelegate other = (MulticastDelegate) value;
+
+			if (delegates == null && other.delegates == null) {
+				/* if they are not equal and the current one is not
+				 * a multicastdelegate then we cannot delete it */
+				return this.Equals (other) ? null : this;
+			} else if (delegates == null) {
+				foreach (var d in other.delegates) {
+					if (this.Equals (d))
+						return null;
+				}
+				return this;
+			} else if (other.delegates == null) {
+				int idx = Array.LastIndexOf (delegates, other);
+				if (idx == -1)
+					return this;
+
+				if (delegates.Length <= 1) {
+					/* delegates.Length should never be equal or
+					 * lower than 1, it should be 2 or greater */
+					throw new InvalidOperationException ();
+				}
+
+				if (delegates.Length == 2)
+					return delegates [idx == 0 ? 1 : 0];
+
+				MulticastDelegate ret = AllocDelegateLike_internal (this);
+				ret.delegates = new Delegate [delegates.Length - 1];
+
+				Array.Copy (delegates, ret.delegates, idx);
+				Array.Copy (delegates, idx + 1, ret.delegates, idx, delegates.Length - idx - 1);
+
+				return ret;
+			} else {
+				/* wild case : remove MulticastDelegate from MulticastDelegate
+				 * complexity is O(m + n), with n the number of elements in
+				 * this.delegates and m the number of elements in other.delegates */
+
+				if (delegates.Equals (other.delegates))
+					return null;
+
+				/* we need to remove elements from the end to the beginning, as
+				 * the addition and removal of delegates behaves like a stack */
+				int idx = LastIndexOf (delegates, other.delegates);
+				if (idx == -1)
+					return this;
+
+				MulticastDelegate ret = AllocDelegateLike_internal (this);
+				ret.delegates = new Delegate [delegates.Length - other.delegates.Length];
+
+				Array.Copy (delegates, ret.delegates, idx);
+				Array.Copy (delegates, idx + other.delegates.Length, ret.delegates, idx, delegates.Length - idx - other.delegates.Length);
+
+				return ret;
+			}
+		}
+
+		public static bool operator == (MulticastDelegate d1, MulticastDelegate d2)
+		{
+			if (d1 == null)
+				return d2 == null;
+
+			return d1.Equals (d2);
+		}
+		
+		public static bool operator != (MulticastDelegate d1, MulticastDelegate d2)
+		{
+			if (d1 == null)
+				return d2 != null;
+
+			return !d1.Equals (d2);
+		}
+
+		internal override object GetTarget()
+		{
+			return delegates?.Length > 0 ? delegates [delegates.Length - 1].GetTarget () : base.GetTarget ();
+		}
+	}
+}