public bool DispatchEvent <T>(T evt) where T : BaseEvent
{
Type type = evt.GetType();
if (!m_handlerTable.ContainsKey(type))
{
return(false);
}
PriorityLinkedList <Delegate> priorityLinkedList = m_handlerTable[type];
LinkedListNode <ElementPriorityPair <Delegate> > linkedListNode = priorityLinkedList.First();
while (linkedListNode != null)
{
LinkedListNode <ElementPriorityPair <Delegate> > next = linkedListNode.Next;
Delegate element = linkedListNode.Value.Element;
if (element.Target.Equals(null))
{
priorityLinkedList.Remove(linkedListNode.Value.Element);
linkedListNode = next;
continue;
}
if ((bool)element.DynamicInvoke(evt))
{
return(true);
}
linkedListNode = linkedListNode.Next;
}
return(false);
}
private PriorityLinkedList <JobTimeoutModel> CreateSimpleQueue()
{
PriorityLinkedList <JobTimeoutModel> pq = new PriorityLinkedList <JobTimeoutModel>();
pq.Enqueue(this.j3);
pq.Enqueue(this.j2);
pq.Enqueue(this.j1);
return(pq);
}
public void TestEmpty()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
pq.Dequeue();
pq.Dequeue();
pq.Dequeue();
Assert.Equal(0, pq.Count);
}
public void TestClear1()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
pq.Clear();
Assert.Equal(0, pq.Count);
Assert.False(pq.Contains(this.j1));
Assert.False(pq.Contains(this.j2));
Assert.False(pq.Contains(this.j3));
}
public PriorityLinkedList <EventHandlerDelegate <TEvent> > GetHandlerList <TEvent>() where TEvent : struct
{
Type typeFromHandle = typeof(TEvent);
if (!m_handlerTable.TryGetValue(typeFromHandle, out object value))
{
value = new PriorityLinkedList <EventHandlerDelegate <TEvent> >();
m_handlerTable.Add(typeFromHandle, value);
}
return((PriorityLinkedList <EventHandlerDelegate <TEvent> >)value);
}
public void TestContains()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
Assert.True(pq.Contains(this.j1));
Assert.True(pq.Contains(this.j2));
Assert.True(pq.Contains(this.j3));
JobTimeoutModel j4 = new JobTimeoutModel("abc", DateTime.Now + TimeSpan.FromMinutes(15), new JobRequest());
Assert.False(pq.Contains(j4));
}
public bool RemoveListener <T>(EventHandlerDelegate <T> handler) where T : BaseEvent
{
Type typeFromHandle = typeof(T);
if (!m_handlerTable.ContainsKey(typeFromHandle))
{
return(false);
}
PriorityLinkedList <Delegate> priorityLinkedList = m_handlerTable[typeFromHandle];
return(priorityLinkedList.Remove(handler));
}
public void AddListener <T>(EventHandlerDelegate <T> handler, Priority priority = Priority.DEFAULT) where T : BaseEvent
{
Type typeFromHandle = typeof(T);
if (!m_handlerTable.ContainsKey(typeFromHandle))
{
m_handlerTable.Add(typeFromHandle, new PriorityLinkedList <Delegate>());
}
PriorityLinkedList <Delegate> priorityLinkedList = m_handlerTable[typeFromHandle];
priorityLinkedList.Add(handler, (int)priority);
}
public void TestPeek()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
JobTimeoutModel front = pq.Peek();
Assert.Equal(this.j1, front);
Assert.Equal(3, pq.Count);
pq.Clear();
front = pq.Peek();
Assert.Null(front);
Assert.Equal(0, pq.Count);
}
public void TestRemove3()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
pq.Remove(this.j3);
JobTimeoutModel d1 = pq.Dequeue();
JobTimeoutModel d2 = pq.Dequeue();
Assert.Equal(d1, this.j1);
Assert.Equal(d2, this.j2);
// queue should be empty now
Assert.Null(pq.Dequeue());
}
public void TestCount1()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
Assert.Equal(3, pq.Count);
pq.Dequeue();
Assert.Equal(2, pq.Count);
pq.Dequeue();
Assert.Equal(1, pq.Count);
pq.Dequeue();
Assert.Equal(0, pq.Count);
pq.Dequeue();
Assert.Equal(0, pq.Count);
pq.Enqueue(this.j1);
Assert.Equal(1, pq.Count);
}
public void TestDequeue()
{
PriorityLinkedList <JobTimeoutModel> pq = this.CreateSimpleQueue();
JobTimeoutModel d1 = pq.Dequeue();
Assert.Equal(2, pq.Count);
JobTimeoutModel d2 = pq.Dequeue();
Assert.Equal(1, pq.Count);
JobTimeoutModel d3 = pq.Dequeue();
Assert.Equal(0, pq.Count);
Assert.Equal(this.j1, d1);
Assert.Equal(this.j2, d2);
Assert.Equal(this.j3, d3);
}
public bool DispatchEvent <T>(T evt) where T : struct
{
Type typeFromHandle = typeof(T);
if (!m_handlerTable.ContainsKey(typeFromHandle))
{
return(false);
}
PriorityLinkedList <EventHandlerDelegate <T> > handlerList = GetHandlerList <T>();
bool copyOnWrite = handlerList.CopyOnWrite;
handlerList.CopyOnWrite = true;
LinkedListNode <ElementPriorityPair <EventHandlerDelegate <T> > > linkedListNode = handlerList.First();
while (linkedListNode != null)
{
LinkedListNode <ElementPriorityPair <EventHandlerDelegate <T> > > next = linkedListNode.Next;
EventHandlerDelegate <T> element = linkedListNode.Value.Element;
if (element.Target != null && element.Target.Equals(null))
{
handlerList.Remove(linkedListNode.Value.Element);
linkedListNode = next;
}
else
{
try
{
if (handlerList.Contains(element) && element(evt))
{
handlerList.CopyOnWrite = copyOnWrite;
return(true);
}
}
catch (Exception ex)
{
Log.LogErrorFormatted(this, "The event handler for event '{0}' threw an exception. Execution will continue but the game may be in a broken state.", typeof(T).FullName);
Log.LogException(this, ex);
}
linkedListNode = next;
}
}
handlerList.CopyOnWrite = copyOnWrite;
return(false);
}
public void SetUp()
{
_logger = new Mock <ILogger>();
_priorityLinkedList = new PriorityLinkedList(_logger.Object);
}
