Dec2017-Script-Dump/UnityEngine/Events/PersistentCall.cs

using System;
using System.Reflection;
using UnityEngine.Serialization;

namespace UnityEngine.Events
{
	// Token: 0x0200047D RID: 1149
	[Serializable]
	internal class PersistentCall
	{
		// Token: 0x17000D38 RID: 3384
		// (get) Token: 0x060039A3 RID: 14755 RVA: 0x00064550 File Offset: 0x00062750
		public Object target
		{
			get
			{
				return this.m_Target;
			}
		}

		// Token: 0x17000D39 RID: 3385
		// (get) Token: 0x060039A4 RID: 14756 RVA: 0x0006456C File Offset: 0x0006276C
		public string methodName
		{
			get
			{
				return this.m_MethodName;
			}
		}

		// Token: 0x17000D3A RID: 3386
		// (get) Token: 0x060039A5 RID: 14757 RVA: 0x00064588 File Offset: 0x00062788
		// (set) Token: 0x060039A6 RID: 14758 RVA: 0x000645A4 File Offset: 0x000627A4
		public PersistentListenerMode mode
		{
			get
			{
				return this.m_Mode;
			}
			set
			{
				this.m_Mode = value;
			}
		}

		// Token: 0x17000D3B RID: 3387
		// (get) Token: 0x060039A7 RID: 14759 RVA: 0x000645B0 File Offset: 0x000627B0
		public ArgumentCache arguments
		{
			get
			{
				return this.m_Arguments;
			}
		}

		// Token: 0x17000D3C RID: 3388
		// (get) Token: 0x060039A8 RID: 14760 RVA: 0x000645CC File Offset: 0x000627CC
		// (set) Token: 0x060039A9 RID: 14761 RVA: 0x000645E8 File Offset: 0x000627E8
		public UnityEventCallState callState
		{
			get
			{
				return this.m_CallState;
			}
			set
			{
				this.m_CallState = value;
			}
		}

		// Token: 0x060039AA RID: 14762 RVA: 0x000645F4 File Offset: 0x000627F4
		public bool IsValid()
		{
			return this.target != null && !string.IsNullOrEmpty(this.methodName);
		}

		// Token: 0x060039AB RID: 14763 RVA: 0x0006462C File Offset: 0x0006282C
		public BaseInvokableCall GetRuntimeCall(UnityEventBase theEvent)
		{
			BaseInvokableCall baseInvokableCall;
			if (this.m_CallState == UnityEventCallState.Off || theEvent == null)
			{
				baseInvokableCall = null;
			}
			else
			{
				MethodInfo methodInfo = theEvent.FindMethod(this);
				if (methodInfo == null)
				{
					baseInvokableCall = null;
				}
				else
				{
					switch (this.m_Mode)
					{
					case PersistentListenerMode.EventDefined:
						baseInvokableCall = theEvent.GetDelegate(this.target, methodInfo);
						break;
					case PersistentListenerMode.Void:
						baseInvokableCall = new InvokableCall(this.target, methodInfo);
						break;
					case PersistentListenerMode.Object:
						baseInvokableCall = PersistentCall.GetObjectCall(this.target, methodInfo, this.m_Arguments);
						break;
					case PersistentListenerMode.Int:
						baseInvokableCall = new CachedInvokableCall<int>(this.target, methodInfo, this.m_Arguments.intArgument);
						break;
					case PersistentListenerMode.Float:
						baseInvokableCall = new CachedInvokableCall<float>(this.target, methodInfo, this.m_Arguments.floatArgument);
						break;
					case PersistentListenerMode.String:
						baseInvokableCall = new CachedInvokableCall<string>(this.target, methodInfo, this.m_Arguments.stringArgument);
						break;
					case PersistentListenerMode.Bool:
						baseInvokableCall = new CachedInvokableCall<bool>(this.target, methodInfo, this.m_Arguments.boolArgument);
						break;
					default:
						baseInvokableCall = null;
						break;
					}
				}
			}
			return baseInvokableCall;
		}

		// Token: 0x060039AC RID: 14764 RVA: 0x00064750 File Offset: 0x00062950
		private static BaseInvokableCall GetObjectCall(Object target, MethodInfo method, ArgumentCache arguments)
		{
			Type type = typeof(Object);
			if (!string.IsNullOrEmpty(arguments.unityObjectArgumentAssemblyTypeName))
			{
				type = Type.GetType(arguments.unityObjectArgumentAssemblyTypeName, false) ?? typeof(Object);
			}
			Type typeFromHandle = typeof(CachedInvokableCall<>);
			Type type2 = typeFromHandle.MakeGenericType(new Type[] { type });
			ConstructorInfo constructor = type2.GetConstructor(new Type[]
			{
				typeof(Object),
				typeof(MethodInfo),
				type
			});
			Object @object = arguments.unityObjectArgument;
			if (@object != null && !type.IsAssignableFrom(@object.GetType()))
			{
				@object = null;
			}
			return constructor.Invoke(new object[] { target, method, @object }) as BaseInvokableCall;
		}

		// Token: 0x060039AD RID: 14765 RVA: 0x00064830 File Offset: 0x00062A30
		public void RegisterPersistentListener(Object ttarget, string mmethodName)
		{
			this.m_Target = ttarget;
			this.m_MethodName = mmethodName;
		}

		// Token: 0x060039AE RID: 14766 RVA: 0x00064844 File Offset: 0x00062A44
		public void UnregisterPersistentListener()
		{
			this.m_MethodName = string.Empty;
			this.m_Target = null;
		}

		// Token: 0x04001184 RID: 4484
		[FormerlySerializedAs("instance")]
		[SerializeField]
		private Object m_Target;

		// Token: 0x04001185 RID: 4485
		[FormerlySerializedAs("methodName")]
		[SerializeField]
		private string m_MethodName;

		// Token: 0x04001186 RID: 4486
		[FormerlySerializedAs("mode")]
		[SerializeField]
		private PersistentListenerMode m_Mode = PersistentListenerMode.EventDefined;

		// Token: 0x04001187 RID: 4487
		[FormerlySerializedAs("arguments")]
		[SerializeField]
		private ArgumentCache m_Arguments = new ArgumentCache();

		// Token: 0x04001188 RID: 4488
		[FormerlySerializedAs("m_Enabled")]
		[SerializeField]
		[FormerlySerializedAs("enabled")]
		private UnityEventCallState m_CallState = UnityEventCallState.RuntimeOnly;
	}
}