/// <summary> /// Realtime analysis enumerable /// </summary> /// <param name="dataConsumer">Data consumer</param> /// <param name="readers">Input</param> /// <param name="stop">Stop function</param> /// <param name="reason">Reason</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The absolute time "sign"</param> /// <returns>The enumerable</returns> public static IEnumerable <object> RealtimeAnalysisEnumerableDirectory(this IDataConsumer dataConsumer, ILogReaderCollection readers, Func <object, bool> stop, string reason, TimeType timeType, bool isAbsoluteTime) { IComponentCollection cc = dataConsumer.CreateCollection(reason); cc.ForEach((ICalculationReason re) => { re.CalculationReason = reason; }); cc.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); IEnumerable <ILogReader> r = readers.Readers; foreach (ILogReader reader in r) { cc.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); IEnumerable <object> en = dataConsumer.RealtimeAnalysisEnumerable(reader, stop, reason, timeType, isAbsoluteTime); object ob = null; foreach (object o in en) { ob = o; } yield return(ob); cc.ForEach((IRealTimeStartStop ss) => { ss.Stop(); }); } cc.ForEach((IRealTimeStartStop ss) => { ss.Stop(); }); }
/// <summary> /// Creates enumerator /// </summary> /// <param name="consumer">The consumer</param> /// <returns>The enumerator</returns> protected virtual IEnumerable <object> Create(IDataConsumer consumer) { Func <object, bool> stop = (object o) => { return(false); }; IDesktop desktop = (consumer as IAssociatedObject).GetRootDesktop(); object l = null; desktop.ForEach((BelongsToCollectionPortable b) => { if (b.Source == consumer) { object o = b.Target; if (o is LogHolder) { LogHolder llh = o as LogHolder; (llh as IAssociatedObject).Prepare(true); l = llh.Reader; } } }); if (l != null) { string reason = Event.Interfaces.StaticExtensionEventInterfaces.PureRealtimeLogAnalysis; IComponentCollection collection = consumer.CreateCollection(reason); collection.ForEach((ICalculationReason r) => { r.CalculationReason = reason; }); if (isDirectoryOriented) { return(consumer.RealtimeAnalysisEnumerableDirectory(l, stop, reason, TimeType.Second, false)); } return(consumer.RealtimeAnalysisEnumerable(l, stop, reason, TimeType.Second, false)); } return(null); }
/// <summary> /// Realtime analysis /// </summary> /// <param name="dataConsumer">Data consumer</param> /// <param name="input">Input</param> /// <param name="act">Action</param> /// <param name="reason">Reason</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The absolute time "sign"</param> public static void RealtimeAnalysis(this IDataConsumer dataConsumer, IEnumerable <object> input, string reason, Action <object> act, TimeType timeType, bool isAbsoluteTime) { IDesktop desktop = (dataConsumer as IAssociatedObject).GetRootDesktop(); IComponentCollection collection = dataConsumer.CreateCollection( reason); StaticExtensionEventInterfaces.NewLog = null; using (IDisposable disp = collection.StartRealtime(timeType, isAbsoluteTime, null, dataConsumer, null, reason) as IDisposable) { IRealtime r = disp as IRealtime; RealtimeProvider p = r.TimeProvider as RealtimeProvider; Dictionary <IReplacedMeasurementParameter, string> d; IEnumerable <object> list = dataConsumer.CreateList(input, collection, out d); DateTime centuryBegin = new DateTime(2001, 1, 1); using (ReplacedMeasurementsBackup backup = new ReplacedMeasurementsBackup(d, r)) { Dictionary <string, object>[] dm = backup.Output; foreach (object obj in list) { try { if (obj is Tuple <INativeReader, object[], DateTime> ) { Tuple <INativeReader, object[], DateTime> t = obj as Tuple <INativeReader, object[], DateTime>; p.DateTime = t.Item3; t.Item1.Read(t.Item2); act(t); continue; } } catch { continue; } Tuple <DateTime, INativeEvent, Dictionary <string, object> > tuple = obj as Tuple <DateTime, INativeEvent, Dictionary <string, object> >; dm[0] = tuple.Item3; DateTime dt = tuple.Item1; p.DateTime = tuple.Item1; tuple.Item2.Force(); act(tuple); } } } }
/// <summary> /// Realtime analysis /// </summary> /// <param name="dataConsumer">Data consumer</param> /// <param name="input">Input</param> /// <param name="stop">Stop function</param> /// <param name="reason">Reason</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The absolute time "sign"</param> public static void RealtimeAnalysis(this IDataConsumer dataConsumer, object input, Func <object, bool> stop, string reason, TimeType timeType, bool isAbsoluteTime) { cadr = 0; IComponentCollection cc = dataConsumer.CreateCollection(reason); if (input is ILogReader) { ILogReader lr = input as ILogReader; cc.ForEach((ICalculationReason re) => { re.CalculationReason = reason; }); cc.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); dataConsumer.RealtimeAnalysis(lr, stop, reason, timeType, isAbsoluteTime); cc.ForEach((IRealTimeStartStop ss) => { ss.Stop(); }); return; } if (input is ILogReaderCollection) { // IComponentCollection cc = dataConsumer.CreateCollection(reason); cc.ForEach((ICalculationReason re) => { re.CalculationReason = reason; }); cc.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); IEnumerable <ILogReader> lr = (input as ILogReaderCollection).Readers; foreach (ILogReader r in lr) { cc.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); bool b = dataConsumer.RealtimeAnalysis(r, stop, reason, timeType, isAbsoluteTime); cc.ForEach((IRealTimeStartStop ss) => { ss.Stop(); }); if (b) { return; } } cc.ForEach((IRealTimeStartStop ss) => { ss.Stop(); }); } if (input is IIterator) { IIterator it = input as IIterator; cc.ForEach((ICalculationReason re) => { re.CalculationReason = reason; }); cc.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); // bool b = dataConsumer.RealtimeAnalysis(it, stop, reason, timeType, isAbsoluteTime); cc.ForEach((IRealTimeStartStop ss) => { ss.Stop(); }); return; } }
/// <summary> /// Analysis of an iterator, modelled after the realtime analysis of log. Most dummy varibales will perhaps be erased /// </summary> /// <param name="dataConsumer"></param> /// <param name="input"></param> /// <param name="stop"></param> /// <param name="reason"></param> /// <param name="timeType"></param> /// <param name="isAbsoluteTime"></param> /// <returns></returns> public static bool RealTimeAnalysis(this IDataConsumer dataConsumer, IIterator input, Func <object, bool> stop, string reason, TimeType timeType, bool isAbsoluteTime) { return(false); IDesktop desktop = (dataConsumer as IAssociatedObject).GetRootDesktop(); IComponentCollection collection = dataConsumer.CreateCollection( reason); StaticExtensionEventInterfaces.NewLog = null; using (IDisposable disp = collection.StartRealtime(timeType, isAbsoluteTime, null, dataConsumer, null, reason) as IDisposable) { IRealtime r = disp as IRealtime; RealtimeProvider p = r.TimeProvider as RealtimeProvider; Dictionary <IReplacedMeasurementParameter, string> d; } }
/// <summary> /// Crerates SCADA /// </summary> protected virtual void CreateScada() { IEnumerable <ICategoryObject> categoryObjects = desktop.CategoryObjects; foreach (ICategoryObject ob in categoryObjects) { IObjectLabel l = ob.Object as IObjectLabel; string name = l.RootName; List <string> list = null; if (objects.ContainsKey(name)) { list = objects[name]; } else { list = new List <string>(); objects[name] = list; } list.Add(ob.GetType().AssemblyQualifiedName); } events.Clear(); dEvents.Clear(); if (consumerName == null) { return; } dataConsumer = desktop.GetObject <IDataConsumer>(consumerName); collection = dataConsumer.CreateCollection("Realtime"); collection.ForEach((Event.Interfaces.IEvent ev) => { string s = (ev as IAssociatedObject).GetRootName(); events.Add(s); dEvents[s] = new EventWrapper(ev); } ); collection.ForEach((IEventHandler eventHandler) => { IEnumerable <Event.Interfaces.IEvent> evs = eventHandler.Events; foreach (Event.Interfaces.IEvent ev in evs) { string s = (ev as IAssociatedObject).GetRootName(); if (events.Contains(s)) { continue; } events.Add(s); dEvents[s] = new EventWrapper(ev); } }); inputs.Clear(); dInput.Clear(); collection.ForEach((ForcedEventData f) => { string s = (f as IAssociatedObject).GetRootName(); List <Tuple <string, object> > l = f.Types; for (int i = 0; i < l.Count; i++) { Tuple <string, object> t = l[i]; int[] k = new int[] { i }; string n = s + "." + t.Item1; inputs.Add(n, t.Item2); dInput[n] = (object obj) => { object[] arr = f.Data; arr[k[0]] = obj; f.Force(); }; } }); outputs.Clear(); dOutput.Clear(); collection.ForEach((IMeasurements measurements) => { string s = (measurements as IAssociatedObject).GetRootName(); for (int i = 0; i < measurements.Count; i++) { IMeasurement measurement = measurements[i]; string n = s + "." + measurement.Name; outputs.Add(n, measurement.Type); dOutput[n] = measurement.Parameter; } }); dConstant.Clear(); collection.ForEach((IAlias alias) => { string s = (alias as IAssociatedObject).GetRootName(); foreach (string name in alias.AliasNames) { string n = s + '.' + name; Tuple <string, object> t = new Tuple <string, object>(n, alias.GetType(name)); dConstant[n] = (object o) => { alias[name] = o; }; } }); }