Example #1
0
        /// <summary>
        /// Creates a list of alarms from a WasObject.
        /// </summary>
        /// <param name="wasObject">A WasObject.</param>
        /// <returns>A list of alarms. Never null.</returns>
        public static List <Alarm> Create(WasObject wasObject)
        {
            var alarms = new List <Alarm>();

            if (wasObject != null && wasObject.Alarms != null && wasObject.Alarms.Count > 0)
            {
                alarms.AddRange(wasObject.Alarms.Select(Create));
            }

            return(alarms);
        }
Example #2
0
        /// <summary>
        /// Updates the (internal) list of alarms using the current WAS-Object.
        /// </summary>
        /// <param name="wasObject">The current object from the WAS.</param>
        public void UpdateAlarmObject(WasObject wasObject)
        {
            this.mAlarms = wasObject.Alarms.
                           Select(alarm => Transformate(alarm)).
                           ToList();

            // Update the WHITE-parsed alarm list
            Dictionary <string, string> tempParsedAlarms = new Dictionary <string, string>();

            foreach (Alarm alarm in this.Alarms)
            {
                if (this.mWhiteParsedAlarms.ContainsKey(alarm.Id))
                {
                    tempParsedAlarms.Add(alarm.Id, this.mWhiteParsedAlarms[alarm.Id]);
                }
            }

            this.mWhiteParsedAlarms = tempParsedAlarms;
        }
Example #3
0
        protected bool Equals(WasObject other)
        {
            if (ReferenceEquals(null, other))
            {
                return(false);
            }
            bool alarms1IsNull = ReferenceEquals(Alarms, null);
            bool alarms2IsNull = ReferenceEquals(other.Alarms, null);

            if (alarms1IsNull && alarms2IsNull)
            {
                return(true);
            }
            if (alarms1IsNull || alarms2IsNull)
            {
                return(false);
            }
            return(Alarms.SequenceEqual(other.Alarms));
        }
Example #4
0
        /// <summary>
        /// The method reads the network stream and will then decode the received WasObject.
        /// Afterwards it calls the 'WasObjectChanged' event iff the WASObject
        /// has changed (Comparison with mLastWasObject).
        /// </summary>
        private void HandleWasData(ITcpClient tcpClient)
        {
            using (MemoryStream stream = tcpClient.ReadNetworkStream(WasObject.XmlWasObjectEndTagRegex))
            {
                WasObject wasObject = null;

                try
                {
                    stream.Position = 0;
                    wasObject       = WasObject.Deserialize(stream);
                }

                catch
                {
                    string xml = Utilities.StreamToString(stream, Constants.WasEncoding);
                    wasObject = WasObject.Deserialize(xml);
                }

                this.mLogger.LogInformation("WAS XML deserialized", InformationType.WasListener_WasObjectDeserialized);

                bool wasObjectChanged = !wasObject.Equals(this.mLastWasObject);

                if (wasObjectChanged && this.WasObjectChanged != null)
                {
                    this.mLastWasObject = wasObject;

                    Thread eventThread = new Thread(new ThreadStart(delegate
                    {
                        this.WasObjectChanged(wasObject);
                    }))
                    {
                        IsBackground = true
                    };

                    eventThread.Start();
                }
            }
        }