//--------------------------------------------------------------------
#region 内部方法
EventCall Parse(Queue <string> stringQueue)
{
string word = null;
EventCall first = null, prev = null, last = null;
while (stringQueue.Count > 0)
{
word = stringQueue.Dequeue();
if (word == "(")
{
last = Parse(stringQueue);
}
else
{
last = ParseFunc(word, stringQueue);
}
if (last == null)
{
continue;
}
if (first == null)
{
first = prev = last;
}
else
{
prev.NextCall = last;
prev = last;
}
last = null;
}
return(first);
}
public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
if (EventCall.TryGetEventCall(fakeObjectCall, out var eventCall))
{
this.fakeManager.EventCallHandler.HandleEventCall(eventCall);
}
}
public virtual void Apply(IInterceptedFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
foreach (var action in this.Actions)
{
action.Invoke(fakeObjectCall);
}
this.applicator.Invoke(fakeObjectCall);
this.ApplyOutAndRefParametersValueProducer(fakeObjectCall);
if (this.CallBaseMethod)
{
if (EventCall.TryGetEventCall(fakeObjectCall, out var eventCall) && eventCall.IsEventRaiser())
{
throw new InvalidOperationException(ExceptionMessages.CannotRaiseEventWhenCallingBaseMethod);
}
fakeObjectCall.CallBaseMethod();
}
else if (this.CallWrappedMethodOn is object wrappedObject)
{
fakeObjectCall.CallWrappedMethod(wrappedObject);
}
}
public void BindTest()
{
EventHolder holder = new EventHolder();
EventCall call = new EventCall();
var handle1 = call.Bind(holder);
//イベント
Assert.IsTrue(call.Message(TestEvent.Event1));
Assert.AreEqual(holder.value, "event1");
//型が違う
Assert.IsFalse(call.Message(TestEvent.Event1, "test"));
Assert.AreNotEqual(holder.value, "test");
//イベントを発火
Assert.IsTrue(call.Message(TestEvent.Event2, "event2"));
Assert.AreEqual(holder.value, "event2");
//再びバインドするため二回イベント呼ばれる
call.Bind(holder);
holder.value = "";
Assert.IsTrue(call.Broadcast(TestEvent.Event3, 123));
Assert.AreEqual(holder.value, "123123");
//一つ目のバインドを解除するので一回だけ呼ばれる
handle1.Dispose();
holder.value = "";
Assert.IsTrue(call.Broadcast(TestEvent.Event3, 123));
Assert.AreEqual(holder.value, "123");
}
public Tester()
{
EventCall call = new EventCall();
m_obj = new GameObject("Tester");
Controller = m_obj.AddComponent <ContentsController>();
}
private void Do(int type, Gesture gt)
{
try
{
if (mIsTouch == false)
{
return;
}
EventCall call = null;
var iter = _allLayers.GetEnumerator();
while (iter.MoveNext())
{
var item = iter.Current;
call = item.Value[type];
if (call != null)
{
if (call(gt))
{
//todo 修改派发
// Facade.TouchNotify.Dispatch((item.Value.Layer), type);
break;
}
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
}
public void AddEvent(int layer, int type, EventCall call)
{
if (!_allLayers.ContainsKey(layer))
{
_allLayers.Add(layer, new LayerInfo(layer));
}
_allLayers[layer][type] = call;
}
public void RegisteEvent(int id, EventDelegate eventDelegate)
{
if (EventDic.ContainsKey(id))
{
EventDic[id].AddEventCall(eventDelegate);
}
else
{
EventCall call = new EventCall(eventDelegate);
EventDic.Add(id, call);
}
}
private void RaiseEvent(EventCall call)
{
var raiseMethod = this.registeredEventHandlers[call.Event];
if (raiseMethod != null)
{
var arguments = call.EventHandler.Target as IEventRaiserArguments;
var sender = arguments.Sender ?? this.FakeObject.Object;
raiseMethod.DynamicInvoke(sender, arguments.EventArguments);
}
}
public void MessageTest5()
{
//実行中に登録したイベントは発火されない
EventCall call = new EventCall();
System.Action action = null;
action = () =>
{
call.Subscribe("Test", action);
};
action();
call.Broadcast("Test");
call.Broadcast("Test");
call.Broadcast("Test");
}
private void HandleEventCall(EventCall eventCall)
{
if (eventCall.IsEventRegistration())
{
if (eventCall.IsEventRaiser())
{
this.RaiseEvent(eventCall);
}
else
{
this.AddEventListener(eventCall);
}
}
else
{
this.RemoveEventListener(eventCall);
}
}
private void HandleEventCall(EventCall eventCall)
{
if (eventCall.IsEventRegistration())
{
if (eventCall.IsEventRaiser())
{
this.RaiseEvent(eventCall);
}
else
{
this.AddEventListener(eventCall);
}
}
else
{
this.RemoveEventListener(eventCall);
}
}
private static void ManageEvents(object fake, Func <EventCall, bool> eventCallPredicate)
{
Guard.AgainstNull(fake, nameof(fake));
var manager = Fake.GetFakeManager(fake);
A.CallTo(fake)
.WithVoidReturnType()
.Where(
call => EventCall.TryGetEventCall(call, out var eventCall) && eventCallPredicate(eventCall),
writer => { }) // This call spec will never be asserted, so we don't need to write a description
.Invokes(call =>
{
if (EventCall.TryGetEventCall(call, out var eventCall))
{
manager.EventCallHandler.HandleEventCall(eventCall);
}
});
}
public void MessageTest1()
{
EventCall call = new EventCall();
int count = 0;
var path = call.Subscribe(TestEvent.Event1, () => count++);
//イベントを発行
Assert.IsTrue(call.Message(TestEvent.Event1));
Assert.AreEqual(count, 1);
//イベントを発行
Assert.IsTrue(call.Message(TestEvent.Event1));
Assert.AreEqual(count, 2);
//登録していないイベント
Assert.IsFalse(call.Message(TestEvent.Event2));
Assert.AreEqual(count, 2);
//パスを解除
path.Dispose();
Assert.IsFalse(call.Message(TestEvent.Event1));
Assert.AreEqual(count, 2);
}
public void Call(string json)
{
var eventobject = JsonConvert.DeserializeObject <dynamic>(json);
var eventname = (string)eventobject.@event;
var timestamp = (DateTime)eventobject.timestamp;
PreEventCall?.Invoke(eventname, timestamp, json);
if (timestamp < IGNORE_DATE)
{
Debug.WriteLine($"Event ignored : [{timestamp}] {eventname}]");
return;
}
var modeltype = GetTypeByEventname(eventname);
if (modeltype != null)
{
Debug.WriteLine($"Call event : [{timestamp}] {eventname}");
var model = default(EventModelBase);
try
{
model = (EventModelBase)JsonConvert.DeserializeObject(json, modeltype, _jsonsettings);
}
catch (Exception ex)
{
Debug.WriteLine($"!!! Unkown format : [{timestamp}] {eventname} - {ex.Message}");
return;
}
EventCall?.Invoke(eventname, model);
CallEvent(model);
}
else
{
Debug.WriteLine($"!!! Unkown event : [{timestamp}] {eventname}");
UnkownEventCall?.Invoke(eventname, timestamp, json);
}
}
private void HandleEventCall(EventCall eventCall)
{
if (eventCall.IsEventRegistration())
{
IEventRaiserArgumentProvider argumentProvider;
if (this.eventHandlerArgumentProviderMap.TryTakeArgumentProviderFor(
eventCall.EventHandler,
out argumentProvider))
{
this.RaiseEvent(eventCall, argumentProvider);
}
else
{
this.AddEventListener(eventCall);
}
}
else
{
this.RemoveEventListener(eventCall);
}
}
public void MessageTest3()
{
EventCall call = new EventCall();
int count1 = 0;
int count2 = 0;
int count3 = 0;
var path1 = call.Subscribe(TestEvent.Event1, () => count1++);
var path2 = call.Subscribe(TestEvent.Event1, () => count2++);
var path3 = call.Subscribe(TestEvent.Event1, () => count3++);
//メッセージは一番最初に登録された物が優先される
for (int i = 0; i < 5; i++)
{
Assert.IsTrue(call.Message(TestEvent.Event1));
Assert.AreEqual(count1, 1 + i);
Assert.AreEqual(count2, 0);
Assert.AreEqual(count3, 0);
}
//一つ解除する
path1.Dispose();
//ブロードキャストは全ての登録イベントに発火する
for (int i = 0; i < 5; i++)
{
Assert.IsTrue(call.Broadcast(TestEvent.Event1));
Assert.AreEqual(count1, 5);
Assert.AreEqual(count2, 1 + i);
Assert.AreEqual(count3, 1 + i);
}
path2.Dispose();
path3.Dispose();
//全て解除すると発火されない
for (int i = 0; i < 5; i++)
{
Assert.IsFalse(call.Broadcast(TestEvent.Event1));
Assert.AreEqual(count1, 5);
Assert.AreEqual(count2, 5);
Assert.AreEqual(count3, 5);
}
}
public void SubCallTest()
{
EventCall root = new EventCall();
EventCall call1 = root.SubCall();
EventCall call2 = root.SubCall();
EventCall call3 = root.SubCall();
EventCall call4 = call1.SubCall();
EventCall call5 = call4.SubCall();
int ret = 0;
var path1 = call1.Subscribe(TestEvent.Event1, () => ret = 1);
call2.Subscribe(TestEvent.Event1, () => ret = 2);
call3.Subscribe(TestEvent.Event1, () => ret = 3);
call4.Subscribe(TestEvent.Event1, () => ret = 4);
call5.Subscribe(TestEvent.Event1, () => ret = 5);
//メッセージが伝播してcall1優先される
Assert.IsTrue(root.Message(TestEvent.Event1));
Assert.AreEqual(ret, 1);
//メッセージが優先される
Assert.IsTrue(call2.Message(TestEvent.Event1));
Assert.AreEqual(ret, 2);
Assert.IsTrue(call3.Message(TestEvent.Event1));
Assert.AreEqual(ret, 3);
//パスがなくなったので、サブコールのイベントが呼ばれる
path1.Dispose();
Assert.IsTrue(root.Message(TestEvent.Event1));
Assert.AreEqual(ret, 4);
//子のサブコールも解放される
call1.Dispose();
Assert.IsFalse(call5.Message(TestEvent.Event1));
Assert.AreEqual(ret, 4);
Assert.IsTrue(root.Message(TestEvent.Event1));
Assert.AreEqual(ret, 2);
}
public void MessageTest2()
{
EventCall call = new EventCall();
int ret = 0;
int count = 0;
var path = call.Subscribe(TestEvent.Event1, (int val) => { ret = val; count++; });
//イベントを発行
Assert.IsTrue(call.Message(TestEvent.Event1, 5));
Assert.AreEqual(ret, 5);
Assert.AreEqual(count, 1);
//イベントを発行
Assert.IsTrue(call.Message(TestEvent.Event1, 7));
Assert.AreEqual(ret, 7);
Assert.AreEqual(count, 2);
//単発イベントでは発火しない
Assert.IsFalse(call.Message(TestEvent.Event1));
Assert.AreEqual(ret, 7);
Assert.AreEqual(count, 2);
//違う方のイベントでは発火しない
Assert.IsFalse(call.Message(TestEvent.Event1, 0.4f));
Assert.AreEqual(ret, 7);
Assert.AreEqual(count, 2);
//登録していないイベント
Assert.IsFalse(call.Message(TestEvent.Event2, 4));
Assert.AreEqual(count, 2);
//パスを解除
path.Dispose();
Assert.IsFalse(call.Message(TestEvent.Event1, 22));
Assert.AreEqual(ret, 7);
Assert.AreEqual(count, 2);
}
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
{
Guard.AgainstNull(fakeObjectCall, nameof(fakeObjectCall));
return(EventCall.TryGetEventCall(fakeObjectCall, out _));
}
private void RemoveEventListener(EventCall call)
{
this.RemoveHandler(call.Event, call.EventHandler);
}
private void RaiseEvent(EventCall call, IEventRaiserArgumentProvider argumentProvider)
{
Delegate raiseMethod;
if (this.RegisteredEventHandlers.TryGetValue(call.Event, out raiseMethod))
{
var arguments = argumentProvider.GetEventArguments(this.FakeManager.Object);
try
{
raiseMethod.DynamicInvoke(arguments);
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
// Exceptions thrown by event handlers should propagate outward as is, not
// be wrapped in a TargetInvocationException.
TryPreserveStackTrace(ex.InnerException);
throw ex.InnerException;
}
throw;
}
}
}
public EventCacheItem(EventType type, Priority priority, EventCall method)
{
this.type = type;
this.method = method;
this.priority = priority;
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
EventCall eventCall = EventCall.GetEventCall(fakeObjectCall);
this.HandleEventCall(eventCall);
}
// Clear all tests
public void Clear()
{
Down = delegate { };
Up = delegate { };
Pressed.Clear();
}
private object[] GetArgumentsFromEventRaiser(EventCall call)
{
var argumentListBuilder = this.eventHandlerArgumentProviderMap.TakeArgumentProviderFor(call.EventHandler);
return argumentListBuilder.GetEventArguments(this.FakeManager.Object);
}
protected override void onGUI()
{
EventCall myTarget = (EventCall)target;
myTarget.Variables["EventName"].Value = EditorGUILayout.TextField("Event Name", myTarget.Variables["EventName"].ConvertedValue <string>());
}
public ObjectPool(EventCall getCallBack, EventCall releaseCallBack)
{
pool = new Stack <T>();
_getCallBack = getCallBack;
_releaseCallBack = releaseCallBack;
}
public bool IsApplicableTo(IFakeObjectCall fakeObjectCall)
{
return(EventCall.GetEvent(fakeObjectCall.Method) != null);
}
private void RemoveEventListener(EventCall call)
{
this.registeredEventHandlers.RemoveHandler(call.Event, call.EventHandler);
}
public void AddTest(ButtonTest other)
{
Down += other.Down;
Up += other.Up;
Pressed.UnionWith(other.Pressed);
}
private void RaiseEvent(EventCall call)
{
Delegate raiseMethod = null;
if (this.RegisteredEventHandlers.TryGetValue(call.Event, out raiseMethod))
{
var arguments = call.EventHandler.Target as IEventRaiserArguments;
var sender = arguments.Sender ?? this.FakeManager.Object;
raiseMethod.DynamicInvoke(sender, arguments.EventArguments);
}
}
private void AddEventListener(EventCall call)
{
this.registeredEventHandlers.AddHandler(call.Event, call.EventHandler);
}
public void RemoveTest(ButtonTest other)
{
Down -= other.Down;
Up -= other.Up;
Pressed.ExceptWith(other.Pressed);
}
public void Run(FlowInstance instance, EventCall call)
{
this.instance = instance;
this.eventCall = call;
if (!instance.CurrentNodes.Any())
{
// Start new
foreach (var startNode in instance.Flow.Nodes.OfType <EventNode>().Where(
x => x.IsStartEvent && x.Id == call.Delegate.EventNodeId))
{
// Pass arguments to event
if (!startNode.ShouldExecute(this, instance.DataScope))
{
continue;
}
// Execute event
Execute(new NodeScope <EventNode> {
Node = startNode, NodeId = startNode.Id, Scope = instance.DataScope
});
}
}
else
{
var executedEvents = new List <NodeScope <EventNode> >();
foreach (var eventNode in instance.CurrentNodes.Where(x => x.NodeId == call.Delegate.EventNodeId))
{
eventNode.Node = instance.Flow.Nodes.OfType <EventNode>().FirstOrDefault(x => x.Id == eventNode.NodeId);
if (!eventNode.Node.ShouldExecute(this, eventNode.Scope))
{
continue;
}
if (Execute(eventNode))
{
executedEvents.Add(eventNode);
}
}
// Remove continued events
foreach (var executedEvent in executedEvents)
{
instance.CurrentNodes.Remove(executedEvent);
}
executedEvents.Clear();
}
while (nextNodes.Any())
{
// Peek first element, get index and remove
var nextNode = nextNodes.First();
var index = nextNodes.IndexOf(nextNode);
nextNodes.Remove(nextNode);
if (nextNode.Node is EventNode)
{
instance.CurrentNodes.Add(new NodeScope <EventNode>
{
Node = nextNode.Node as EventNode,
Scope = nextNode.Scope,
NodeId = nextNode.NodeId
});
}
else
{
Execute(nextNode, index);
}
}
}
private void AddEventListener(EventCall call)
{
this.AddHandler(call.Event, call.EventHandler);
}
public void RemoveEvent(int layer, int type, EventCall call)
{
_allLayers[layer][type] = null;
}
public ButtonTest(EventCall Down, EventCall Up, TestEvent Pressed)
{
this.Down = Down;
this.Up = Up;
this.Pressed.Add(Pressed);
}
