public override int HandleEvent(string sSender, int iChannelId, int iEventId, string sEvent) { var guid = Guid.NewGuid().ToString(); GlobalDefinition.LoggerWrapper.LogDevInfo("####################Receive Event.#######################" + guid + "########eventId:" + iEventId); if (String.IsNullOrEmpty(sSender)) { GlobalDefinition.LoggerWrapper.LogDevInfo( "####################processed Event.#######################" + guid + "########eventId:" + iEventId); GlobalDefinition.LoggerWrapper.LogDevWarning("PRFE Event sender is empty ...."); return(0); } if (null == EventMap || !EventMap.ContainsKey(iEventId)) { GlobalDefinition.LoggerWrapper.LogDevInfo( "####################processed Event.#######################" + guid + "########eventId:" + iEventId); GlobalDefinition.LoggerWrapper.LogDevWarning("EventMap is null or not contains this event id"); return(0); } if (null == EventMap[iEventId]) { GlobalDefinition.LoggerWrapper.LogDevInfo( "####################processed Event.#######################" + guid + "########eventId:" + iEventId); GlobalDefinition.LoggerWrapper.LogDevWarning("There's no event handler of this event id"); return(0); } try { EventMap[iEventId](sEvent); } catch (Exception ex) { GlobalDefinition.LoggerWrapper.LogDevInfo( "####################processed Event exception.#######################" + guid + "########eventId:" + iEventId); GlobalDefinition.LoggerWrapper.LogDevError(ex.Message); GlobalDefinition.LoggerWrapper.LogDevError(ex.StackTrace); return(0); } GlobalDefinition.LoggerWrapper.LogDevInfo("####################processed Event.#######################" + guid + "########eventId:" + iEventId); return(0); }
private DiagnosticAnalyzerService(IDiagnosticUpdateSourceRegistrationService registrationService) : this() { _eventMap = new EventMap(); _eventQueue = new SimpleTaskQueue(TaskScheduler.Default); registrationService.Register(this); }
private void RunButtonClick(string name) { if (EventMap.ContainsKey(name)) { EventMap[name].Invoke(); } }
private async Task RecoveryProcessing(ISession session, EventModel data, Vwcontractorsite siteInfo, IEnumerable <UInt32> bitflags) { IList <EventMap> map = await GetEventMaps(session, data, bitflags); if (map == null || map.Count == 0) // 없는 이벤트 일 경우 무시 { return; } var existEvents = await session.CreateCriteria <EventRecord>().Add( Restrictions.InG <int>("Eventcode", map.Select(x => x.Eventcode)) && Restrictions.IsNull("Recoveryts") && Restrictions.Eq("Devicetype", data.DeviceType) && Restrictions.Eq("Deviceindex", data.DeviceIndex) && Restrictions.Eq("Siteid", data.SiteId)).ListAsync <EventRecord>(); foreach (EventRecord record in existEvents) { DateTime dt = DateTime.FromFileTime(data.UnixTimestamp); record.Recoveryts = dt; await session.UpdateAsync(record); EventMap target_map = map.FirstOrDefault(x => x.Eventcode == record.Eventcode); await RecoveryReportMMS(siteInfo.Represenation, data.SiteId, data.DeviceType, data.DeviceIndex, target_map.Name, dt); logger.LogWarning($"[RECOVERY EVENT] SITEID: {data.SiteId} / GC:{data.GroupCode} / BF:tail{data.BitFlag} / DT:{data.DeviceType} / INDEX:{data.DeviceIndex}"); } }
private async Task FaultProcessing(ISession session, EventModel data, Vwcontractorsite siteInfo, IEnumerable <UInt32> bitflags) { foreach (UInt32 bit in bitflags) { // 발생한 이벤트가 이미 존재하는지 체크 EventMap map = await GetEventMap(session, data, bit); // 복구 이벤트 체크 if (map == null) { continue; } var existEvents = await session.CreateCriteria <EventRecord>().Add( Restrictions.Eq("Eventcode", map.Eventcode) && Restrictions.IsNull("Recoveryts") && Restrictions.Eq("Devicetype", data.DeviceType) && Restrictions.Eq("Deviceindex", data.DeviceIndex) && Restrictions.Eq("Siteid", data.SiteId)).ListAsync <EventRecord>(); // 이벤트가 발생했는데, 기존에 엑티브 이벤트에 없을 경우 이벤트를 인서트 한다. if (existEvents.Count == 0) { EventRecord newEventRecode = new EventRecord(); DateTime dt = DateTime.FromFileTime(data.UnixTimestamp); newEventRecode.Createts = dt; newEventRecode.Eventcode = map.Eventcode; newEventRecode.Siteid = data.SiteId; newEventRecode.Devicetype = data.DeviceType; newEventRecode.Deviceindex = data.DeviceIndex; await session.SaveOrUpdateAsync(newEventRecode); await FaultReportMMS(siteInfo.Represenation, data.SiteId, data.DeviceType, data.DeviceIndex, map.Name, dt); logger.LogWarning($"[NEW EVENT] SITEID: {data.SiteId} / GC:{data.GroupCode} / BF:{bit} / DT:{data.DeviceType} / INDEX:{data.DeviceIndex}"); } } }
private void InitEventMap() { float avgLatitude = 0, avgLongitude = 0; foreach (var activity in _event.Activities) { var pin = new Pin(); var place = activity.Place; pin.Position = new Position(place.Latitude, place.Longitude); pin.Label = place.Name; avgLatitude += place.Latitude; avgLongitude += place.Longitude; EventMap.Pins.Add(pin); } if (_event.Activities.Count != 0) { avgLatitude /= _event.Activities.Count; avgLongitude /= _event.Activities.Count; EventMap.MoveToRegion( MapSpan.FromCenterAndRadius( new Position(avgLatitude, avgLongitude), Distance.FromMeters(400))); } else { EventMap.MoveToRegion( MapSpan.FromCenterAndRadius( new Position(53.118293, 23.149717), Distance.FromMeters(300))); } }
protected override void OnDisposing(bool manually) { if (music != null) { music.FadeOut(1f); music = null; } foreach (Player player in players) { player.AttachToHud(null); } if (eventMap != null) { eventMap.Dispose(); eventMap = null; } if (tileMap != null) { tileMap.ReleaseResources(); tileMap = null; } api = null; base.OnDisposing(manually); }
public FireDBRefence(MonoBehaviour c, DatabaseReference body) { context = c; this.body = body; valueEventMap = new EventMap <ValueChangedEventArgs>(body, t => { return(t.Snapshot); }, h => { this.body.ValueChanged += h; }, h => { this.body.ValueChanged -= h; }); addEventMap = new EventMap <ChildChangedEventArgs>(body, t => { return(t.Snapshot); }, h => { this.body.ChildAdded += h; }, h => { this.body.ChildAdded -= h; }); removeEventMap = new EventMap <ChildChangedEventArgs>(body, t => { return(t.Snapshot); }, h => { this.body.ChildRemoved += h; }, h => { this.body.ChildRemoved -= h; }); }
public void PostConstruct() { EventMap.Map(AppEvent.Pause, OnAppPause); CheckOrientation(); StartOrientationCheck(); }
public DiagnosticService( IAsynchronousOperationListenerProvider listenerProvider, [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners ) { // we use registry service rather than doing MEF import since MEF import method can have race issue where // update source gets created before aggregator - diagnostic service - is created and we will lose events fired before // the aggregator is created. _updateSources = ImmutableHashSet <IDiagnosticUpdateSource> .Empty; // queue to serialize events. _eventMap = new EventMap(); _eventQueue = new TaskQueue( listenerProvider.GetListener(FeatureAttribute.DiagnosticService), TaskScheduler.Default ); _gate = new object(); _map = new Dictionary < IDiagnosticUpdateSource, Dictionary <Workspace, Dictionary <object, Data> > >(); _eventListenerTracker = new EventListenerTracker <IDiagnosticService>( eventListeners, WellKnownEventListeners.DiagnosticService ); }
private static void AddPropertyAssertHandlersToRegistry(Recorder recorder, EventMap events) { if (Types.HasPublicProperties(recorder.TesterType)) { Delegate handler = Delegate.CreateDelegate(typeof(EventHandler), recorder, PropertyAssert, false); events.Add(PropertyAssert, handler); } }
public SolutionCrawlerProgressReporter(IAsynchronousOperationListener listener) { _listener = listener; _eventQueue = new SimpleTaskQueue(TaskScheduler.Default); _eventMap = new EventMap(); _count = 0; }
protected override async Task OnMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs e) { byte[] packet = e.ApplicationMessage.Payload; string txt = Encoding.UTF8.GetString(packet); try { EventModel data = JsonConvert.DeserializeObject <EventModel>(txt); using (var session = sessionFactory.OpenStatelessSession()) using (var transaction = session.BeginTransaction()) { EventMap map = session.Get <EventMap>(data.EventCode); string redisKey = $"SID{data.SiteId}.EVENT.{data.DeviceId}"; Program.logger.Info($"Received Event: {data.EventCode} / Status: {data.Status}"); switch (data.Status) { case EventStatus.New: await redisDb.HashSetAsync(redisKey, $"{data.EventCode}", bool.TrueString); // 새로 발생한 이벤트 IList <EventRecord> ev = await FindNewRaiseEvent(data.EventCode, session.CreateCriteria <EventRecord>()); if (ev.Count > 0) { return; } EventRecord newEventRecode = new EventRecord(); newEventRecode.CreateDT = new DateTime(1970, 1, 1).AddSeconds(data.UnixTimestamp).ToLocalTime(); newEventRecode.EventId = data.EventCode; newEventRecode.SiteId = data.SiteId; newEventRecode.DeviceId = data.DeviceId; await session.InsertAsync(newEventRecode); break; case EventStatus.Recovery: await redisDb.HashSetAsync(redisKey, $"{data.EventCode}", bool.FalseString); var rc_result = await FindNewRaiseEvent(data.EventCode, session.CreateCriteria <EventRecord>()); if (rc_result.Count > 0) { foreach (EventRecord exist_record in rc_result) { exist_record.RecoveryDT = new DateTime(1970, 1, 1).AddSeconds(data.UnixTimestamp).ToLocalTime(); await session.UpdateAsync(exist_record); } } break; } await transaction.CommitAsync(); } } catch (Exception ex) { Program.logger.Error(ex, ex.Message); } }
public static EventMap Instance() { if (instance == null) { instance = new EventMap(); } return(instance); }
void Instantiate() { //DontDestroyOnLoad(gameObject); recognizer = new GestureRecognizer(); recognizer.SetRecognizableGestures(GestureSettings.Tap); recognizer.TappedEvent += OnTap; eventMap = new EventMap(); GrantControl(); }
private void Awake() { m_onKeyEventMap = new EventMap <KeyCode> (); m_onKeyUpEventMap = new EventMap <KeyCode> (); m_onKeyDownEventMap = new EventMap <KeyCode> (); m_onMouseButtonEventMap = new EventMap <int> (); m_onMouseButtonUpEventMap = new EventMap <int> (); m_onMouseButtonDownEventMap = new EventMap <int> (); }
static bool IsOverriden(EventMap emap, Type thisType, Type t) { var method = thisType.GetMethod(emap.MethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (method == null) { throw new InvalidOperationException("Invalid event mapping: method '" + emap.MethodName + "' not found in type '" + t + "'"); } return(method.DeclaringType != t); }
private DiagnosticAnalyzerService(IDiagnosticUpdateSourceRegistrationService registrationService) : this() { _eventMap = new EventMap(); // use diagnostic event task scheduler so that we never flood async events queue with million of events. // queue itself can handle huge number of events but we are seeing OOM due to captured data in pending events. _eventQueue = new SimpleTaskQueue(s_eventScheduler); registrationService.Register(this); }
private void AddRecorderToRegistry(Type type, Listener listener) { Recorder recorder = (Recorder)Activator.CreateInstance(type, new object[] { listener }); EventMap events = new EventMap(); AddEventHandlersToRegistry(recorder, type, events); AddPropertyAssertHandlersToRegistry(recorder, events); eventTable.Add(recorder.RecorderType, events); }
public void ProcessEvent(string eventName) { if (EventMap.ContainsKey(eventName)) { List <CCFunction> cceventList = EventMap[eventName]; foreach (CCFunction function in cceventList) { ProcessFunction(function); } } }
public EventsMapViewModel(IMobEventManager mobEventManager) { Title = "Events Map"; this.mobEventManager = mobEventManager; Map = new EventMap() { MapType = MapType.Street }; Task.Run(async() => await LoadEvents()); }
// Start is called before the first frame update void Start() { Transform canvas = FindObjectOfType <Canvas>().transform; fuelSlider = Instantiate(fuelSlider, canvas); meteorSlider = Instantiate(meteorSlider, canvas); EMPSlider = Instantiate(EMPSlider, canvas); progressSlider = Instantiate(progressSlider, canvas); events = FindObjectOfType <EventMap>(); progressSlider = Instantiate(progressSlider, canvas); }
public DiagnosticService([ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners) : this() { // queue to serialize events. _eventMap = new EventMap(); _eventQueue = new SimpleTaskQueue(TaskScheduler.Default); _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.DiagnosticService); _gate = new object(); _map = new Dictionary <IDiagnosticUpdateSource, Dictionary <object, Data> >(); }
private async void LoadMap(DojoLocation location) { Geopoint eventLocation = GenerateGeoPoint(location); MapIcon myPOI = new MapIcon { Location = eventLocation, NormalizedAnchorPoint = new Point(0.5, 1.0), Title = "Coder Dojo!", ZIndex = 0 }; EventMap.MapElements.Add(myPOI); await EventMap.TrySetSceneAsync(MapScene.CreateFromLocationAndRadius(eventLocation, 150)); }
protected void CheckCollisions(float timeMult) { if (health <= 0) { return; } TileMap tiles = levelHandler.TileMap; if (tiles != null) { AABB adjustedAABB = AABBInner + new Vector2(speedX * timeMult, speedY * timeMult); if (tiles.CheckWeaponDestructible(ref adjustedAABB, WeaponType, strength) > 0) { if (WeaponType != WeaponType.Freezer) { if (owner != null) { owner.AddScore(50); } } DecreaseHealth(1); } else if (!tiles.IsTileEmpty(ref AABBInner, false)) { EventMap events = levelHandler.EventMap; bool handled = false; if (events != null) { Vector3 pos = Transform.Pos; ushort[] eventParams = null; switch (events.GetEventByPosition(pos.X + speedX * timeMult, pos.Y + speedY * timeMult, ref eventParams)) { case EventType.ModifierRicochet: if (lastRicochetFrame + 2 < Time.FrameCount) { lastRicochet = null; lastRicochetFrame = Time.FrameCount; OnRicochet(); handled = true; } break; } } if (!handled) { OnHitWall(); } } } }
/// <summary> /// Maps an event handler of an Xwt component to an event identifier. /// </summary> /// <param name="eventId">The event identifier (must be valid event enum value /// like <see cref="Xwt.Backends.WidgetEvent"/>, identifying component specific events).</param> /// <param name="type">The Xwt component type.</param> /// <param name="methodName">The <see cref="System.Reflection.MethodInfo.Name"/> of the event handler.</param> private static void MapEvent (object eventId, Type type, string methodName) { List<EventMap> events; if (!overridenEventMap.TryGetValue (type, out events)) { events = new List<EventMap> (); overridenEventMap [type] = events; } EventMap emap = new EventMap () { MethodName = methodName, EventId = eventId }; events.Add (emap); }
internal void WriteEventMap(EventMap eventMap) { if (eventMap.UpdateRowOnRebuild) { object[] parts = new object[] { GetMemberIndex(eventMap.Parent), GetMemberIndex(eventMap.Events[0]), }; eventMap.MetaDataRow = new MetaDataRow(parts); } writer.Write(eventMap.MetaDataRow.GenerateBytes()); }
public DiagnosticService([ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners) : this() { // queue to serialize events. _eventMap = new EventMap(); // use diagnostic event task scheduler so that we never flood async events queue with million of events. // queue itself can handle huge number of events but we are seeing OOM due to captured data in pending events. _eventQueue = new SimpleTaskQueue(s_eventScheduler); _listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.DiagnosticService); _gate = new object(); _map = new Dictionary <IDiagnosticUpdateSource, Dictionary <object, Data> >(); }
public EventMapEntry(PEFile module, byte *ptr, int metadataOffset, int row) { this.module = module; this.metadata = module.Metadata; this.RID = row; var rowOffset = metadata.GetTableMetadataOffset(TableIndex.EventMap) + metadata.GetTableRowSize(TableIndex.EventMap) * (row - 1); this.Offset = metadataOffset + rowOffset; int typeDefSize = metadata.GetTableRowCount(TableIndex.TypeDef) < ushort.MaxValue ? 2 : 4; int eventDefSize = metadata.GetTableRowCount(TableIndex.Event) < ushort.MaxValue ? 2 : 4; this.eventMap = new EventMap(ptr + rowOffset, typeDefSize, eventDefSize); }
public DiagnosticService( IAsynchronousOperationListenerProvider listenerProvider, [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners) : this() { // queue to serialize events. _eventMap = new EventMap(); _eventQueue = new TaskQueue(listenerProvider.GetListener(FeatureAttribute.DiagnosticService), TaskScheduler.Default); _gate = new object(); _map = new Dictionary <IDiagnosticUpdateSource, Dictionary <Workspace, Dictionary <object, Data> > >(); _eventListenerTracker = new EventListenerTracker <IDiagnosticService>(eventListeners, WellKnownEventListeners.DiagnosticService); }
protected virtual bool OnPerish(ActorBase collider) { EventMap events = api.EventMap; if (events != null && (flags & ActorInstantiationFlags.IsCreatedFromEventMap) != 0) { events.Deactivate(originTile.X, originTile.Y); events.StoreTileEvent(originTile.X, originTile.Y, EventType.Empty); } api.RemoveActor(this); return(true); }
internal PXCMTouchlessController(EventMap maps, IntPtr instance, Boolean delete) : base(instance, delete) { this.maps = maps; }
internal PXCMTouchlessController(IntPtr instance, Boolean delete) : base(instance, delete) { maps = new EventMap(); }
static bool IsOverriden (EventMap emap, Type thisType, Type t) { var method = thisType.GetMethod (emap.MethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (method == null) throw new InvalidOperationException ("Invalid event mapping: method '" + emap.MethodName + "' not found in type '" + t + "'"); return method.DeclaringType != t; }
static bool IsOverriden (EventMap emap, Type thisType, Type t) { var method = thisType.GetMethod (emap.MethodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); return method.DeclaringType != t; }