//-------------------------------------------------------------------- #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 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); }