public EventCallbackList Get(EventCallbackList initializer)
{
EventCallbackList element;
if (m_Stack.Count == 0)
{
if (initializer != null)
{
element = new EventCallbackList(initializer);
}
else
{
element = new EventCallbackList();
}
}
else
{
element = m_Stack.Pop();
if (initializer != null)
{
element.AddRange(initializer);
}
}
return(element);
}
public EventCallbackList Get(EventCallbackList initializer)
{
EventCallbackList eventCallbackList;
if (this.m_Stack.Count == 0)
{
if (initializer != null)
{
eventCallbackList = new EventCallbackList(initializer);
}
else
{
eventCallbackList = new EventCallbackList();
}
}
else
{
eventCallbackList = this.m_Stack.Pop();
if (initializer != null)
{
eventCallbackList.AddRange(initializer);
}
}
return(eventCallbackList);
}
public void InvokeCallbacks(EventBase evt)
{
if (m_Callbacks == null)
{
return;
}
m_IsInvoking++;
for (var i = 0; i < m_Callbacks.Count; i++)
{
if (evt.isImmediatePropagationStopped)
{
break;
}
m_Callbacks[i].Invoke(evt);
}
m_IsInvoking--;
if (m_IsInvoking == 0)
{
// If callbacks were modified during callback invocation, update them now.
if (m_TemporaryCallbacks != null)
{
ReleaseCallbackList(m_Callbacks);
m_Callbacks = GetCallbackList(m_TemporaryCallbacks);
ReleaseCallbackList(m_TemporaryCallbacks);
m_TemporaryCallbacks = null;
}
}
}
public void InvokeCallbacks(EventBase evt)
{
if (this.m_Callbacks != null)
{
this.m_IsInvoking++;
for (int i = 0; i < this.m_Callbacks.Count; i++)
{
if (evt.isImmediatePropagationStopped)
{
break;
}
this.m_Callbacks[i].Invoke(evt);
}
this.m_IsInvoking--;
if (this.m_IsInvoking == 0)
{
if (this.m_TemporaryCallbacks != null)
{
EventCallbackRegistry.ReleaseCallbackList(this.m_Callbacks);
this.m_Callbacks = EventCallbackRegistry.GetCallbackList(this.m_TemporaryCallbacks);
EventCallbackRegistry.ReleaseCallbackList(this.m_TemporaryCallbacks);
this.m_TemporaryCallbacks = null;
}
}
}
}
private EventCallbackList GetCallbackListForWriting()
{
EventCallbackList result;
if (this.m_IsInvoking > 0)
{
if (this.m_TemporaryCallbacks == null)
{
if (this.m_Callbacks != null)
{
this.m_TemporaryCallbacks = EventCallbackRegistry.GetCallbackList(this.m_Callbacks);
}
else
{
this.m_TemporaryCallbacks = EventCallbackRegistry.GetCallbackList(null);
}
}
result = this.m_TemporaryCallbacks;
}
else
{
if (this.m_Callbacks == null)
{
this.m_Callbacks = EventCallbackRegistry.GetCallbackList(null);
}
result = this.m_Callbacks;
}
return(result);
}
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new()
{
if (callback == null)
{
throw new ArgumentException("callback parameter is null");
}
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackList callbackList = GetCallbackListForReading();
if (callbackList != null)
{
var functor = callbackList.Find(eventTypeId, callback, callbackPhase) as EventCallbackFunctor <TEventType, TCallbackArgs>;
if (functor != null)
{
functor.userArgs = userArgs;
return;
}
}
callbackList = GetCallbackListForWriting();
callbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, callbackPhase));
}
EventCallbackList GetCallbackListForWriting()
{
if (m_IsInvoking > 0)
{
if (m_TemporaryCallbacks == null)
{
if (m_Callbacks != null)
{
m_TemporaryCallbacks = GetCallbackList(m_Callbacks);
}
else
{
m_TemporaryCallbacks = GetCallbackList();
}
}
return(m_TemporaryCallbacks);
}
else
{
if (m_Callbacks == null)
{
m_Callbacks = GetCallbackList();
}
return(m_Callbacks);
}
}
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, Capture useCapture = Capture.NoCapture) where TEventType : EventBase <TEventType>, new()
{
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useCapture == Capture.Capture ? CallbackPhase.CaptureAndTarget : CallbackPhase.TargetAndBubbleUp;
if (ShouldRegisterCallback(eventTypeId, callback, callbackPhase))
{
EventCallbackList callbackList = GetCallbackListForWriting();
callbackList.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, callbackPhase));
}
}
bool UnregisterCallback(long eventTypeId, Delegate callback, TrickleDown useTrickleDown)
{
if (callback == null)
{
return(false);
}
EventCallbackList callbackList = GetCallbackListForWriting();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
return(callbackList.Remove(eventTypeId, callback, callbackPhase));
}
bool UnregisterCallback(long eventTypeId, Delegate callback, Capture useCapture)
{
if (callback == null)
{
return(false);
}
EventCallbackList callbackList = GetCallbackListForWriting();
var callbackPhase = useCapture == Capture.Capture ? CallbackPhase.CaptureAndTarget : CallbackPhase.TargetAndBubbleUp;
return(callbackList.Remove(eventTypeId, callback, callbackPhase));
}
public void RegisterCallback <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TCallbackArgs userArgs, Capture useCapture = Capture.NoCapture) where TEventType : EventBase <TEventType>, new()
{
long eventTypeId = EventBase <TEventType> .TypeId();
CallbackPhase phase = (useCapture != Capture.Capture) ? CallbackPhase.TargetAndBubbleUp : CallbackPhase.CaptureAndTarget;
if (this.ShouldRegisterCallback(eventTypeId, callback, phase))
{
EventCallbackList callbackListForWriting = this.GetCallbackListForWriting();
callbackListForWriting.Add(new EventCallbackFunctor <TEventType, TCallbackArgs>(callback, userArgs, phase));
}
}
private bool ShouldRegisterCallback(long eventTypeId, Delegate callback, CallbackPhase phase)
{
bool result;
if (callback == null)
{
result = false;
}
else
{
EventCallbackList callbackListForReading = this.GetCallbackListForReading();
result = (callbackListForReading == null || !callbackListForReading.Contains(eventTypeId, callback, phase));
}
return(result);
}
public void AddRange(EventCallbackList list)
{
this.m_List.AddRange(list.m_List);
foreach (EventCallbackFunctorBase eventCallbackFunctorBase in list.m_List)
{
if (eventCallbackFunctorBase.phase == CallbackPhase.CaptureAndTarget)
{
this.capturingCallbackCount++;
}
else if (eventCallbackFunctorBase.phase == CallbackPhase.TargetAndBubbleUp)
{
this.bubblingCallbackCount++;
}
}
}
private bool UnregisterCallback(long eventTypeId, Delegate callback, Capture useCapture)
{
bool result;
if (callback == null)
{
result = false;
}
else
{
EventCallbackList callbackListForWriting = this.GetCallbackListForWriting();
CallbackPhase phase = (useCapture != Capture.Capture) ? CallbackPhase.TargetAndBubbleUp : CallbackPhase.CaptureAndTarget;
result = callbackListForWriting.Remove(eventTypeId, callback, phase);
}
return(result);
}
public void AddRange(EventCallbackList list)
{
m_List.AddRange(list.m_List);
foreach (var item in list.m_List)
{
if (item.phase == CallbackPhase.TrickleDownAndTarget)
{
trickleDownCallbackCount++;
}
else if (item.phase == CallbackPhase.TargetAndBubbleUp)
{
bubbleUpCallbackCount++;
}
}
}
bool ShouldRegisterCallback(long eventTypeId, Delegate callback, CallbackPhase phase)
{
if (callback == null)
{
return(false);
}
EventCallbackList callbackList = GetCallbackListForReading();
if (callbackList != null)
{
return(!callbackList.Contains(eventTypeId, callback, phase));
}
return(true);
}
public void AddRange(EventCallbackList list)
{
m_List.AddRange(list.m_List);
foreach (var item in list.m_List)
{
if (item.phase == CallbackPhase.CaptureAndTarget)
{
capturingCallbackCount++;
}
else if (item.phase == CallbackPhase.TargetAndBubbleUp)
{
bubblingCallbackCount++;
}
}
}
public void RegisterCallback <TEventType>(EventCallback <TEventType> callback, TrickleDown useTrickleDown = TrickleDown.NoTrickleDown) where TEventType : EventBase <TEventType>, new()
{
if (callback == null)
{
throw new ArgumentException("callback parameter is null");
}
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
EventCallbackList callbackList = GetCallbackListForReading();
if (callbackList == null || callbackList.Contains(eventTypeId, callback, callbackPhase) == false)
{
callbackList = GetCallbackListForWriting();
callbackList.Add(new EventCallbackFunctor <TEventType>(callback, callbackPhase));
}
}
internal bool TryGetUserArgs <TEventType, TCallbackArgs>(EventCallback <TEventType, TCallbackArgs> callback, TrickleDown useTrickleDown, out TCallbackArgs userArgs) where TEventType : EventBase <TEventType>, new()
{
userArgs = default(TCallbackArgs);
if (callback == null)
{
return(false);
}
EventCallbackList list = GetCallbackListForReading();
long eventTypeId = EventBase <TEventType> .TypeId();
var callbackPhase = useTrickleDown == TrickleDown.TrickleDown ? CallbackPhase.TrickleDownAndTarget : CallbackPhase.TargetAndBubbleUp;
var functor = list.Find(eventTypeId, callback, callbackPhase) as EventCallbackFunctor <TEventType, TCallbackArgs>;
if (functor == null)
{
return(false);
}
userArgs = functor.userArgs;
return(true);
}
private static void ReleaseCallbackList(EventCallbackList toRelease)
{
EventCallbackRegistry.s_ListPool.Release(toRelease);
}
private static EventCallbackList GetCallbackList(EventCallbackList initializer = null)
{
return(EventCallbackRegistry.s_ListPool.Get(initializer));
}
public EventCallbackList(EventCallbackList source)
{
m_List = new List <EventCallbackFunctorBase>(source.m_List);
trickleDownCallbackCount = 0;
bubbleUpCallbackCount = 0;
}
public EventCallbackList(EventCallbackList source)
{
m_List = new List <EventCallbackFunctorBase>(source.m_List);
capturingCallbackCount = 0;
bubblingCallbackCount = 0;
}
public void Release(EventCallbackList element)
{
element.Clear();
m_Stack.Push(element);
}
