SharpSCADA/SCADA/Program/DataService/Condition.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;

namespace DataService
{
    public delegate void AlarmEventHandler(object sender, AlarmItem e);

    public interface IEvent
    {
        bool IsEnabled { get; set; }
        bool IsAcked { get; set; }
        bool IsActived { get; set; }
        Severity Severity { get; }
        EventType EventType { get; }
        DateTime LastActive { get; set; }
        string Comment { get; }
    }

    public abstract class ICondition : IEvent, IDisposable, IComparable<ICondition>, IEquatable<ICondition>
    {
        public const string ALARMSTOP = "Alarm Clear";
        protected bool _enable, _ack, _active;
        protected int _id;
        protected DateTime _timeStamp;
        protected SubAlarmType _tempType;
        protected SubCondition[] _subConditions;

        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }

        public bool IsEnabled
        {
            get
            {
                return _enable;
            }
            set
            {
                _enable = value;
            }
        }

        public bool IsActived
        {
            get
            {
                return _active;
            }
            set
            {
                _active = value;
            }
        }

        public bool IsAcked
        {
            get
            {
                return _ack;
            }
            set
            {
                _ack = value;
                if (_ack)
                {
                    _tempType = SubAlarmType.None;
                    _lastAckTime = DateTime.Now;
                    if (_ack && AlarmAck != null)
                    {
                        foreach (EventHandler deleg in AlarmAck.GetInvocationList())
                        {
                            deleg.BeginInvoke(this, EventArgs.Empty, null, null);
                        }
                    }
                }
            }
        }

        public abstract AlarmType AlarmType
        {
            get;
        }

        public EventType EventType
        {
            get
            {
                return EventType.ConditionEvent;
            }
        }


        protected ConditionType _conditionType;
        public ConditionType ConditionType
        {
            get
            {
                return _conditionType;
            }
            set
            {
                _conditionType = value;
            }
        }

        protected DateTime _lastAckTime, _condLastActive, _lastInactive;
        public DateTime LastAckTime
        {
            get
            {
                return _lastAckTime;
            }
            set
            {
                _lastAckTime = value;
            }
        }

        public DateTime SubCondLastActive
        {
            get
            {
                return _current.StartTime;
            }
            //set
            //{
            //    _subCondLastActive = value;
            //}
        }

        public DateTime LastActive
        {
            get
            {
                return _condLastActive;
            }
            set
            {
                _condLastActive = value;
            }
        }

        public DateTime LastInactive
        {
            get
            {
                return _lastInactive;
            }
            set
            {
                _lastInactive = value;
            }
        }

        protected AlarmItem _current;

        protected SubAlarmType _activeSub;
        public SubAlarmType ActiveSubCondition
        {
            get
            {
                return _activeSub;
            }
            protected set
            {
                _activeSub = value;
            }
        }

        public Severity Severity
        {
            get
            {
                return _current.Severity;
            }
        }

        public string Message
        {
            get
            {
                return _current.AlarmText;
            }
        }

        public abstract string Value
        {
            get;
        }

        protected float _para;
        public float Para
        {
            get
            {
                return _para;
            }
            set
            {
                _para = value;
            }
        }

        protected float _deadBand;
        public float DeadBand
        {
            get
            {
                return _deadBand;
            }
            set
            {
                _deadBand = value;
            }
        }

        protected int _delay;
        public int Delay
        {
            get
            {
                return _delay;
            }
            set
            {
                _delay = value;
            }
        }

        protected string _comment;
        public string Comment
        {
            get
            {
                return _comment;
            }
            set
            {
                _comment = value;
            }
        }

        protected string _source;
        public string Source
        {
            get
            {
                return _source;
            }
        }

        public IList<SubCondition> SubConditions
        {
            get
            {
                return _subConditions;
            }
        }

        public AlarmEventHandler AlarmActive;
        public EventHandler AlarmAck;

        protected ICondition(int id, ConditionType conditionType, string source, string comment, float para, float deadBand, int delay)
        {
            this._id = id;
            this._conditionType = conditionType;
            this._para = para;
            this._source = source;
            this._comment = comment;
            this._deadBand = deadBand;
            this._delay = delay;
            this._current = new AlarmItem();
        }

        public abstract bool AddSubCondition(SubCondition condition);

        public abstract bool RemoveSubCondition(SubCondition condition);

        protected abstract void OnActive(SubCondition condition, Storage value, DateTime timeStamp);

        protected abstract void OnInActive(Storage value);

        public int CompareTo(ICondition other)
        {
            int comp1 = ((int)this.Severity).CompareTo((int)other.Severity);
            return comp1 == 0 ? this.LastActive.CompareTo(other.LastActive) : -comp1;
        }

        public bool Equals(ICondition other)
        {
            if (other == null) return false;
            return this._id == other._id;
        }

        public virtual void Dispose()
        {
            _current = null;
            AlarmAck = null;
            AlarmActive = null; ;
        }
    }

    public abstract class SimpleCondition : ICondition, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        public override string Value
        {
            get
            {
                return _tag == null ? null : _tag.ToString();
            }
        }

        protected ITag _tag;
        public ITag Tag
        {
            get
            {
                return _tag;
            }
            set
            {
                if (_tag != null)
                    _tag.ValueChanging -= CheckAlarm;
                _tag = value;
                if (_tag != null)
                    _tag.ValueChanging += CheckAlarm;
            }
        }

        protected SimpleCondition(int id, ConditionType conditionType, string source, string comment, float para, float deadBand, int delay) :
            base(id, conditionType, source, comment, para, deadBand, delay)
        {
        }

        protected override void OnActive(SubCondition condition, Storage value, DateTime timeStamp)
        {
            if (condition.SubAlarmType != ActiveSubCondition)
            {
                if (condition.SubAlarmType != _tempType)
                {
                    _timeStamp = timeStamp;
                    _tempType = condition.SubAlarmType;
                }
                if (_delay == 0 || (timeStamp - _timeStamp).TotalMilliseconds > _delay)
                {
                    if (ActiveSubCondition == SubAlarmType.None)
                    {
                        _active = true;
                        _condLastActive = timeStamp;
                    }
                    _ack = false;
                    ActiveSubCondition = condition.SubAlarmType;
                    _current.Duration = timeStamp - SubCondLastActive;
                    _current = new AlarmItem(timeStamp, condition.Message, _tag.GetValue(value), ActiveSubCondition, condition.Severity, _id, _source);
                    if (AlarmActive != null)
                    {
                        foreach (AlarmEventHandler deleg in AlarmActive.GetInvocationList())
                        {
                            deleg.BeginInvoke(this, _current, null, null);
                        }
                    }
                    RaiseChanged("Value");
                }
            }
            else
            {
                RaiseChanged("Value");
            }
        }

        protected override void OnInActive(Storage value)
        {
            if (ActiveSubCondition != SubAlarmType.None)
            {
                _active = false;
                ActiveSubCondition = SubAlarmType.None;
                _current.Duration = DateTime.Now - SubCondLastActive;
                _current = new AlarmItem(DateTime.Now, string.Concat("【", _current.AlarmText, "】", ALARMSTOP), _tag.GetValue(value), SubAlarmType.None, Severity.Normal, _id, _source);
                if (AlarmActive != null)
                {
                    foreach (AlarmEventHandler deleg in AlarmActive.GetInvocationList())
                    {
                        deleg.BeginInvoke(this, _current, null, null);
                    }
                }
            }
        }

        protected void RaiseChanged(string property)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(property));
            }
        }

        public override void Dispose()
        {
            base.Dispose();
            PropertyChanged = null;
            if (_tag != null)
                _tag.ValueChanging -= CheckAlarm;
        }

        protected abstract void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e);

        public override AlarmType AlarmType
        {
            get
            {
                return AlarmType.None;
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            return true;
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            return true;
        }
    }

    public sealed class ComplexCondition : ICondition, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        public override string Value
        {
            get
            {
                return Convert.ToString(_current.AlarmValue);
            }
        }

        public ComplexCondition(int id, string source, string comment, float deadBand, int delay) :
            base(id, ConditionType.Absolute, source, comment, 0f, deadBand, delay)
        {
            _subConditions = new SubCondition[1]
                {
                    new SubCondition(SubAlarmType.Dsc)
                };
        }

        protected override void OnActive(SubCondition condition, Storage value, DateTime timeStamp)
        {
            if (condition.SubAlarmType != ActiveSubCondition)
            {
                if (condition.SubAlarmType != _tempType)
                {
                    _timeStamp = timeStamp;
                    _tempType = condition.SubAlarmType;
                }
                if (_delay == 0 || (timeStamp - _timeStamp).TotalMilliseconds > _delay)
                {
                    if (ActiveSubCondition == SubAlarmType.None)
                    {
                        _active = true;
                        _condLastActive = timeStamp;
                    }
                    _ack = false;
                    ActiveSubCondition = condition.SubAlarmType;
                    _current.Duration = timeStamp - SubCondLastActive;
                    _current = new AlarmItem(timeStamp, condition.Message, true, ActiveSubCondition, condition.Severity, _id, _source);
                    if (AlarmActive != null)
                    {
                        foreach (AlarmEventHandler deleg in AlarmActive.GetInvocationList())
                        {
                            deleg.BeginInvoke(this, _current, null, null);
                        }
                    }
                    if (PropertyChanged != null)
                    {
                        PropertyChanged(this, new PropertyChangedEventArgs("Value"));
                    }
                }
            }
            else
            {
                if (PropertyChanged != null)
                {
                    PropertyChanged(this, new PropertyChangedEventArgs("Value"));
                }
            }
        }

        protected override void OnInActive(Storage value)
        {
            if (ActiveSubCondition != SubAlarmType.None)
            {
                _active = false;
                ActiveSubCondition = SubAlarmType.None;
                _current.Duration = DateTime.Now - SubCondLastActive;
                _current = new AlarmItem(DateTime.Now, string.Concat("【", _current.AlarmText, "】", ALARMSTOP), false, SubAlarmType.None, Severity.Normal, _id, _source);
                if (AlarmActive != null)
                {
                    foreach (AlarmEventHandler deleg in AlarmActive.GetInvocationList())
                    {
                        deleg.BeginInvoke(this, _current, null, null);
                    }
                }
            }
        }

        public Action SetFunction(Delegate tagChanged)
        {
            var _func = tagChanged as Func<bool>;
            if (_func != null)
            {
                return delegate
                {
                    if (_enable)
                    {
                        SubCondition condition = _subConditions[0];
                        if (condition.IsEnabled)
                        {
                            if (_func())
                            {
                                OnActive(condition, Storage.Empty, DateTime.Now);
                                return;
                            }
                        }
                        OnInActive(Storage.Empty);
                    }
                };
            }
            else
                return null;
        }

        public override void Dispose()
        {
            base.Dispose();
            PropertyChanged = null;
        }

        public override AlarmType AlarmType
        {
            get
            {
                return AlarmType.Complex;
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.Dsc:
                    _subConditions[0] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.Dsc:
                    _subConditions[0] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }

    }

    public sealed class LevelAlarm : SimpleCondition
    {
        public override AlarmType AlarmType
        {
            get { return AlarmType.Level; }
        }

        public LevelAlarm(int id, string source, string comment, float deadBand = 0f, int delay = 0) :
            base(id, ConditionType.Absolute, source, comment, 0, deadBand, delay)
        {
            _subConditions = new SubCondition[4]
                {
                     new SubCondition(SubAlarmType.HiHi),
                     new SubCondition(SubAlarmType.High),
                     new SubCondition(SubAlarmType.LoLo),
                     new SubCondition(SubAlarmType.Low)
                };
        }

        protected override void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e)
        {
            if (_enable)
            {
                SubCondition condition;
                float value = _tag.ScaleToValue(e.NewValue);
                for (int i = 0; i < _subConditions.Length; i++)
                {
                    if (_subConditions[i].IsEnabled)
                    {
                        condition = _subConditions[i];
                        if (i < 2)//Hi Alarm
                        {
                            if (value > condition.Threshold)
                            {
                                OnActive(condition, e.NewValue, e.NewTimeStamp);
                                return;
                            }
                            else if (_deadBand > 0 && ActiveSubCondition == condition.SubAlarmType && value > condition.Threshold - _deadBand)
                            {
                                return;
                            }
                        }
                        else//Low Alarm
                        {
                            if (value < condition.Threshold)
                            {
                                OnActive(condition, e.NewValue, e.NewTimeStamp);
                                return;
                            }
                            else if (_deadBand > 0 && ActiveSubCondition == condition.SubAlarmType && value > condition.Threshold + _deadBand)
                            {
                                return;
                            }
                        }
                    }
                }
                OnInActive(e.NewValue);
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.HiHi:
                    _subConditions[0] = condition;
                    return true;
                case SubAlarmType.High:
                    _subConditions[1] = condition;
                    return true;
                case SubAlarmType.LoLo:
                    _subConditions[2] = condition;
                    return true;
                case SubAlarmType.Low:
                    _subConditions[3] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.HiHi:
                    _subConditions[0] = SubCondition.Empty;
                    return true;
                case SubAlarmType.High:
                    _subConditions[1] = SubCondition.Empty;
                    return true;
                case SubAlarmType.LoLo:
                    _subConditions[2] = SubCondition.Empty;
                    return true;
                case SubAlarmType.Low:
                    _subConditions[3] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }
    }

    public sealed class DevAlarm : SimpleCondition
    {
        public override AlarmType AlarmType
        {
            get { return AlarmType.Dev; }
        }

        public DevAlarm(int id, ConditionType conditionType, string source, string comment, float para, float deadBand = 0f, int delay = 0) :
            base(id, conditionType, source, comment, para, deadBand, delay)
        {
            _subConditions = new SubCondition[2]
                { 
                    new SubCondition(SubAlarmType.MajDev),
                    new SubCondition(SubAlarmType.MinDev)          
                };
        }

        protected override void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e)
        {
            if (_enable)
            {
                float value = _tag.ScaleToValue(e.NewValue) - _para;
                SubCondition condition;
                for (int i = 0; i < _subConditions.Length; i++)
                {
                    if (_subConditions[i].IsEnabled)
                    {
                        condition = _subConditions[i];
                        if (value > (_conditionType == ConditionType.Absolute ? condition.Threshold : _para * condition.Threshold))
                        {
                            OnActive(condition, e.NewValue, e.NewTimeStamp);
                            return;
                        }
                        else if (_deadBand > 0 && ActiveSubCondition == condition.SubAlarmType &&
                            ((_conditionType == ConditionType.Absolute && value > condition.Threshold - _deadBand)
                                || (_conditionType == ConditionType.Percent && value > _para * (condition.Threshold - _deadBand))))
                        {
                            return;
                        }
                    }
                }
                OnInActive(e.NewValue);
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.MajDev:
                    _subConditions[0] = condition;
                    return true;
                case SubAlarmType.MinDev:
                    _subConditions[1] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.MajDev:
                    _subConditions[0] = SubCondition.Empty;
                    return true;
                case SubAlarmType.MinDev:
                    _subConditions[1] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }
    }

    public sealed class DigitAlarm : SimpleCondition
    {
        public override AlarmType AlarmType
        {
            get { return AlarmType.Dsc; }
        }

        public DigitAlarm(int id, string source = null, string comment = null, int delay = 0) :
            base(id, ConditionType.Absolute, source, comment, 0, 0f, delay)
        {
            _subConditions = new SubCondition[1]
                {
                    new SubCondition(SubAlarmType.Dsc)
                };
        }

        protected override void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e)
        {
            if (_enable)
            {
                SubCondition condition = _subConditions[0];
                if (condition.IsEnabled)
                {
                    if (e.NewValue.Boolean == condition.Threshold > 0)
                    {
                        OnActive(condition, e.NewValue, e.NewTimeStamp);
                        return;
                    }
                }
                OnInActive(e.NewValue);
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.Dsc:
                    _subConditions[0] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.Dsc:
                    _subConditions[0] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }
    }

    public sealed class WordDigitAlarm : SimpleCondition
    {
        public override AlarmType AlarmType
        {
            get { return AlarmType.WordDsc; }
        }

        public WordDigitAlarm(int id, string source = null, string comment = null, int delay = 0) :
            base(id, ConditionType.Absolute, source, comment, 0, 0f, delay)
        {
            _subConditions = new SubCondition[16];
            for (int i = 0; i < 16; i++)
            {
                _subConditions[i].SubAlarmType = SubAlarmType.Dsc;
                _subConditions[i].Threshold = i;
            };
        }

        protected override void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e)
        {
            if (_enable)
            {
                short newvalue = e.NewValue.Int16;
                short oldvlaue = e.OldValue.Int16;
                if (newvalue == 0 && oldvlaue != 0)
                {
                    OnInActive(e.NewValue);
                    return;
                }
                for (short i = 0; i < _subConditions.Length; i++)
                {
                    SubCondition condition = _subConditions[i];
                    if (condition.IsEnabled)
                    {
                        int mask = 1 << i;
                        int newval = mask & newvalue;
                        int oldval = mask & oldvlaue;
                        if (newval != 0 && oldval == 0)
                        {
                            OnActive(condition, new Storage { Int16 = i }, e.NewTimeStamp);
                        }
                    }
                }
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.Dsc:
                    int index = (int)condition.Threshold;
                    if (index >= 0 && index < 16)
                        _subConditions[index] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.Dsc:
                    int index = (int)condition.Threshold;
                    if (index >= 0 && index < 16)
                        _subConditions[index] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }

        protected override void OnActive(SubCondition condition, Storage value, DateTime timeStamp)
        {
            if (ActiveSubCondition == SubAlarmType.None)
            {
                _active = true;
                _condLastActive = timeStamp;
            }
            _ack = false;
            ActiveSubCondition = condition.SubAlarmType;
            _current = new AlarmItem(timeStamp, condition.Message, value.Int16, ActiveSubCondition, condition.Severity, _id, _source);
            if (AlarmActive != null)
            {
                foreach (AlarmEventHandler deleg in AlarmActive.GetInvocationList())
                {
                    deleg.BeginInvoke(this, _current, null, null);
                }
            }
            RaiseChanged("Value");
        }

        protected override void OnInActive(Storage value)
        {
            if (ActiveSubCondition != SubAlarmType.None)
            {
                _active = false;
                ActiveSubCondition = SubAlarmType.None;
                _current.Duration = DateTime.Now - LastActive;
                _current = new AlarmItem(DateTime.Now, string.Concat("【", Comment, "】", ALARMSTOP), 0, SubAlarmType.None, Severity.Normal, _id, _source);
                if (AlarmActive != null)
                {
                    foreach (AlarmEventHandler deleg in AlarmActive.GetInvocationList())
                    {
                        deleg.BeginInvoke(this, _current, null, null);
                    }
                }
            }
        }
    }

    public sealed class QualitiesAlarm : SimpleCondition
    {
        public override AlarmType AlarmType
        {
            get { return AlarmType.Quality; }
        }

        public QualitiesAlarm(int id, string source, string comment, int delay = 0) :
            base(id, ConditionType.Absolute, source, comment, 0, 0f, delay)
        {
            _subConditions = new SubCondition[1]
                {
                    new SubCondition(SubAlarmType.BadPV)
                };
        }

        protected override void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e)
        {
            if (_enable)
            {
                SubCondition condition = _subConditions[0];
                if (condition.IsEnabled)
                {
                    if (e.Quality != QUALITIES.QUALITY_GOOD)
                        OnActive(condition, e.NewValue, e.NewTimeStamp);
                    return;
                }
                OnInActive(e.NewValue);
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.BadPV:
                    _subConditions[0] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.BadPV:
                    _subConditions[0] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }
    }

    public sealed class ROCAlarm : SimpleCondition
    {
        public override AlarmType AlarmType
        {
            get { return AlarmType.ROC; }
        }


        public ROCAlarm(int id, string souce, string comment, float deadBand = 0f, int delay = 0) :
            base(id, ConditionType.Percent, souce, comment, 0, deadBand, delay)
        {
            _subConditions = new SubCondition[2]
                {
                    new SubCondition(SubAlarmType.MajROC),
                    new SubCondition(SubAlarmType.MinROC)
                };
        }

        protected override void CheckAlarm(object sender, ValueChangingEventArgs<Storage> e)
        {
            if (_enable)
            {
                float value = (float)((_tag.ScaleToValue(e.NewValue) - e.OldValue.Single) / (e.NewTimeStamp - e.OldTimeStamp).TotalMilliseconds);
                SubCondition condition;
                for (int i = 0; i < _subConditions.Length; i++)
                {
                    if (_subConditions[i].IsEnabled)
                    {
                        condition = _subConditions[i];
                        if (value > condition.Threshold)
                        {
                            OnActive(condition, e.NewValue, e.NewTimeStamp);
                            return;
                        }
                        else if (_deadBand > 0 && ActiveSubCondition == condition.SubAlarmType && value > condition.Threshold - _deadBand)
                        {
                            return;
                        }
                    }
                }
                OnInActive(e.NewValue);
            }
        }

        public override bool AddSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.MajROC:
                    _subConditions[0] = condition;
                    return true;
                case SubAlarmType.MinROC:
                    _subConditions[1] = condition;
                    return true;
                default:
                    return false;
            }
        }

        public override bool RemoveSubCondition(SubCondition condition)
        {
            switch (condition.SubAlarmType)
            {
                case SubAlarmType.MajROC:
                    _subConditions[0] = SubCondition.Empty;
                    return true;
                case SubAlarmType.MinROC:
                    _subConditions[1] = SubCondition.Empty;
                    return true;
                default:
                    return false;
            }
        }
    }

    public struct SubCondition
    {
        public bool IsEnabled;

        public SubAlarmType SubAlarmType;

        public Severity Severity;

        public float Threshold;

        public string Message;

        public SubCondition(SubAlarmType type, float threshold = 0f, Severity severity = Severity.Normal, string message = "", bool enabled = true)
        {
            this.SubAlarmType = type;
            this.Threshold = threshold;
            this.Severity = severity;
            this.Message = message;
            this.IsEnabled = enabled;
        }

        public static readonly SubCondition Empty = new SubCondition(SubAlarmType.None, 0f, Severity.Normal, "正常", false);
    }

    public class CompareCondBySource : IComparer<ICondition>
    {
        public int Compare(ICondition x, ICondition y)
        {
            if (x == null || x.Source == null)
            {
                return y == null || y.Source == null ? 0 : 1;
            }
            else
            {
                return y == null || y.Source == null ? 1 : x.Source.CompareTo(y.Source);
            }
        }
    }
}