AlarmHandler.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using DirectOutput.General.Statistics;

namespace DirectOutput.PinballSupport
{
    public class AlarmHandler
    {
        private TimeSpanStatisticsItem AlarmStatistics;
        private TimeSpanStatisticsItem IntervalAlarmStatistics;

        public DateTime GetNextAlarmTime()
        {
            DateTime IA = GetNextIntervalAlarm();
            DateTime A = GetNextAlarm();

            if (IA < A)
            {
                return IA;
            }
            return A;
        }

        public bool ExecuteAlarms(DateTime AlarmTime)
        {
            bool AlarmsExecuted = false;

            AlarmsExecuted |= Alarm(AlarmTime);
            AlarmsExecuted |= IntervalAlarm(AlarmTime);

            return AlarmsExecuted;
        }





        #region IntervalAlarm
        private object IntervalAlarmLocker = new object();
        private List<IntervalAlarmSettingBase> IntervalAlarmList = new List<IntervalAlarmSettingBase>();
        private abstract class IntervalAlarmSettingBase
        {
            public int IntervalMs { get; set; }
            public DateTime NextAlarm { get; set; }
            public abstract void Execute();


        }

        private class IntervalAlarmSettingPara : IntervalAlarmSettingBase
        {

            public Action<object> IntervalAlarmHandler { get; set; }
            public object Para { get; set; }


            public override void Execute()
            {
                try
                {
                    IntervalAlarmHandler(Para);
                }
                catch (Exception E)
                {
                    throw new Exception("A exception occured in IntervalAlarm for AlarmHandler {0} with parameter {1}.".Build(IntervalAlarmHandler.ToString(), Para.ToString().Replace("\n", ",")), E);
                }
            }

            public IntervalAlarmSettingPara() { }
            public IntervalAlarmSettingPara(int IntervalMs, Action<object> IntervalAlarmHandler, object Para)
            {
                this.IntervalAlarmHandler = IntervalAlarmHandler;
                this.IntervalMs = IntervalMs;
                this.NextAlarm = DateTime.Now.AddMilliseconds(IntervalMs);
                this.Para = Para;
            }
        }

        private class IntervalAlarmSettingNoPara : IntervalAlarmSettingBase
        {

            public Action IntervalAlarmHandler { get; set; }


            public override void Execute()
            {
                try
                {
                    IntervalAlarmHandler();
                }
                catch (Exception E)
                {
                    throw new Exception("A exception occured in IntervalAlarm for AlarmHandler {0}.".Build(IntervalAlarmHandler.ToString()), E);
                }
            }

            public IntervalAlarmSettingNoPara() { }
            public IntervalAlarmSettingNoPara(int IntervalMs, Action IntervalAlarmHandler)
            {
                this.IntervalAlarmHandler = IntervalAlarmHandler;
                this.IntervalMs = IntervalMs;
                this.NextAlarm = DateTime.Now.AddMilliseconds(IntervalMs);
            }
        }

        private DateTime GetNextIntervalAlarm()
        {
            if (IntervalAlarmList.Count > 0)
            {
                return IntervalAlarmList.Min(x => x.NextAlarm);
            }
            return DateTime.MaxValue;
        }

        private bool IntervalAlarm(DateTime AlarmTime)
        {
            lock (IntervalAlarmLocker)
            {
                bool AlarmTriggered = false;
                IntervalAlarmList.Where(x => x.NextAlarm <= AlarmTime).ToList().ForEach(delegate(IntervalAlarmSettingBase S)
                {
                    IntervalAlarmStatistics.MeasurementStart();
                    try
                    {
                        S.Execute();
                    }
                    catch (Exception E)
                    {
                        Log.Exception("A exception occured when excuting the handler for a interval alarm. This interval alarm will be disabled.", E);
                    }
                    IntervalAlarmStatistics.MeasurementStop();
                    AlarmTriggered = true;

                    if (S.NextAlarm.AddMilliseconds(S.IntervalMs) <= AlarmTime)
                    {
                        S.NextAlarm = AlarmTime.AddMilliseconds(1);
                    }
                    else
                    {
                        S.NextAlarm = S.NextAlarm.AddMilliseconds(S.IntervalMs);
                    }
                });
                return AlarmTriggered;
            }
        }

        public void RegisterIntervalAlarm(int IntervalMs, Action IntervalAlarmHandler)
        {
            lock (IntervalAlarmLocker)
            {
                UnregisterIntervalAlarm(IntervalAlarmHandler);
                IntervalAlarmList.Add(new IntervalAlarmSettingNoPara(IntervalMs, IntervalAlarmHandler));
            }
        }


        public void UnregisterIntervalAlarm(Action IntervalAlarmHandler)
        {
            lock (IntervalAlarmLocker)
            {
                IntervalAlarmList.RemoveAll(x => x is IntervalAlarmSettingNoPara && ((IntervalAlarmSettingNoPara)x).IntervalAlarmHandler == IntervalAlarmHandler);
            }
        }


        public void RegisterIntervalAlarm(int IntervalMs, Action<object> IntervalAlarmHandler, object Parameter)
        {
            lock (IntervalAlarmLocker)
            {
                UnregisterIntervalAlarm(IntervalAlarmHandler);
                IntervalAlarmList.Add(new IntervalAlarmSettingPara(IntervalMs, IntervalAlarmHandler, Parameter));
            }
        }


        public void UnregisterIntervalAlarm(Action<object> IntervalAlarmHandler)
        {
            lock (IntervalAlarmLocker)
            {
                IntervalAlarmList.RemoveAll(x => x is IntervalAlarmSettingPara && ((IntervalAlarmSettingPara)x).IntervalAlarmHandler == IntervalAlarmHandler);
            }
        }

        #endregion



        #region Alarm
        private object AlarmLocker = new object();
        private List<AlarmSettingsBase> AlarmList = new List<AlarmSettingsBase>();

        private abstract class AlarmSettingsBase
        {
            public DateTime AlarmTime { get; set; }
            public abstract void Execute();
        }

        private class AlarmSettingNoPara : AlarmSettingsBase
        {

            public Action AlarmHandler { get; set; }


            public override void Execute()
            {
                try
                {
                    AlarmHandler();
                }
                catch (Exception E)
                {
                    Log.Exception("A exception occured for AlarmHandler {0}.".Build(AlarmHandler.ToString()), E);
                }
            }

            public AlarmSettingNoPara() { }
            public AlarmSettingNoPara(DateTime AlarmTime, Action AlarmHandler)
            {
                this.AlarmTime = AlarmTime;
                this.AlarmHandler = AlarmHandler;

            }
        }

        private class AlarmSettingPara : AlarmSettingsBase
        {

            public Action<object> AlarmHandler { get; set; }
            public object Para { get; set; }

            public override void Execute()
            {
                try
                {
                    AlarmHandler(Para);
                }
                catch (Exception E)
                {
                    Log.Exception("A exception occured for AlarmHandler {0} with parameter {1}.".Build(AlarmHandler.ToString(), Para.ToString().Replace("\n", ",")), E);
                }
            }

            public AlarmSettingPara() { }
            public AlarmSettingPara(DateTime AlarmTime, Action<object> AlarmHandler, object Para)
            {
                this.AlarmTime = AlarmTime;
                this.AlarmHandler = AlarmHandler;
                this.Para = Para;
            }
        }

        private DateTime GetNextAlarm()
        {
            if (AlarmList.Count > 0)
            {
                return AlarmList.Min(x => x.AlarmTime);
            }
            return DateTime.MaxValue;
        }

        private bool Alarm(DateTime AlarmTime)
        {

            lock (AlarmLocker)
            {
                List<AlarmSettingsBase> L = AlarmList.Where(x => x.AlarmTime <= AlarmTime).ToList();
                AlarmList.RemoveAll(x => x.AlarmTime <= AlarmTime);
                L.ForEach(delegate(AlarmSettingsBase S)
                {
                    S.Execute();
                });
                return (L.Count > 0);
            }
        }





        public void RegisterAlarm(int DurationMs, Action AlarmHandler, bool DontUnregister = false)
        {
            RegisterAlarm(DateTime.Now.AddMilliseconds(DurationMs), AlarmHandler, DontUnregister);
        }

        public void RegisterAlarm(DateTime AlarmTime, Action AlarmHandler, bool DontUnregister = false)
        {
            lock (AlarmLocker)
            {
                if (!DontUnregister) UnregisterAlarm(AlarmHandler);
                AlarmList.Add(new AlarmSettingNoPara(AlarmTime, AlarmHandler));
            }
        }


        public void UnregisterAlarm(Action AlarmHandler)
        {
            lock (AlarmLocker)
            {
                AlarmList.RemoveAll(x => x is AlarmSettingNoPara && ((AlarmSettingNoPara)x).AlarmHandler == AlarmHandler);
            }
        }


        public void RegisterAlarm(int DurationMs, Action<object> AlarmHandler, object Parameter, bool DontUnregister = false)
        {
            RegisterAlarm(DateTime.Now.AddMilliseconds(DurationMs), AlarmHandler, Parameter, DontUnregister);
        }

        public void RegisterAlarm(DateTime AlarmTime, Action<object> AlarmHandler, object Parameter, bool DontUnregister = false)
        {
            lock (AlarmLocker)
            {
                if(!DontUnregister) UnregisterAlarm(AlarmHandler);
                AlarmList.Add(new AlarmSettingPara(AlarmTime, AlarmHandler, Parameter));
            }
        }


        public void UnregisterAlarm(Action<object> AlarmHandler)
        {
            lock (AlarmLocker)
            {
                AlarmList.RemoveAll(x => x is AlarmSettingPara && ((AlarmSettingPara)x).AlarmHandler == AlarmHandler);
            }
        }

        #endregion


        public void Init(Pinball Pinball)
        {
            AlarmStatistics = new TimeSpanStatisticsItem() { Name = "Alarm calls", GroupName = "Pinball - Alarm calls" };
            Pinball.TimeSpanStatistics.Add(AlarmStatistics);
            IntervalAlarmStatistics = new TimeSpanStatisticsItem() { Name = "Interval Alarm calls", GroupName = "Pinball - Alarm calls" };
            Pinball.TimeSpanStatistics.Add(IntervalAlarmStatistics);
        }

        public void Finish()
        {

            AlarmList.Clear();
            IntervalAlarmList.Clear();
        }


        #region Constructor



        public AlarmHandler()
        {


        }




        #endregion



    }
}