/// <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;
};
}
});
}
