using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CategoryTheory;
using MathGraph;
using DiagramUI;
using DiagramUI.Interfaces;
using DiagramUI.Labels;
using DiagramUI.Aliases;
using BaseTypes;
using DataPerformer.Interfaces;
using DataPerformer.Helpers;
namespace DataPerformer
{
/// <summary>
/// Pure static performer for extension methods
/// </summary>
public static class StaticExtension
{
#region Fields
/*
/// <summary>
/// Default time provider
/// </summary>
public static readonly ITimeMeasureProvider TimeProvider = new TimeMeasureProvider();
*/
#endregion
#region Public Members
/// <summary>
/// Strategy
/// </summary>
private static IDataPerformerRuntimeFactory factory;
/// <summary>
/// Desktop
/// </summary>
private static IDesktop desktop;
/// <summary>
/// Step
/// </summary>
static private int stepNumber;
/// <summary>
/// Number of step
/// </summary>
static public int StepNumber
{
get
{
return stepNumber;
}
set
{
stepNumber = value;
}
}
/// <summary>
/// Runtime factory
/// </summary>
public static IDataPerformerRuntimeFactory Factory
{
get
{
return factory;
}
set
{
factory = value;
}
}
/// <summary>
/// Desktop
/// </summary>
public static IDesktop Desktop
{
get
{
return desktop;
}
set
{
desktop = value;
}
}
/// <summary>
/// Clean measures
/// </summary>
/// <param name="measures">Measures to clean</param>
public static void Clean(this IMeasure[] measures)
{
for (int i = 0; i < measures.Length; i++)
{
measures[i] = null;
}
}
/// <summary>
/// Fills measures by zero c=constants
/// </summary>
/// <param name="measures">Measuresd</param>
public static void FillByDoubleZero(this IMeasure[] measures)
{
Double a = 0;
double b = 0;
for (int i = 0; i < measures.Length; i++)
{
IMeasure m = measures[i];
if (m == null)
{
measures[i] = new ConstantMeasure(b, a, "");
}
}
}
/// <summary>
/// Fills measure by double constant
/// </summary>
/// <param name="measures">All measures</param>
/// <param name="i">Measure number</param>
/// <param name="x">Double constant</param>
public static void FillMeasureByDouble(this IMeasure[] measures, int i, double x)
{
Double a = 0;
if (measures[i] == null)
{
measures[i] = new ConstantMeasure(x, a, "");
}
}
/// <summary>
/// Updates measurements
/// </summary>
/// <param name="measurements">Measurements to update</param>
public static void UpdateChildrenData(this ICollection<IMeasurements> measurements)
{
foreach (IMeasurements m in measurements)
{
m.UpdateMeasurements();
}
}
/// <summary>
/// Sets aliases by vector components
/// </summary>
/// <param name="aliases">Array of aliases</param>
/// <param name="aliasOffset">Offset of aliases</param>
/// <param name="vector">Double vector</param>
/// <param name="vectorOffset">Vector offset</param>
/// <param name="lengh">Length</param>
public static void SetAliases(this AliasName[] aliases, int aliasOffset, double[] vector,
int vectorOffset, int lengh)
{
for (int i = 0; i < lengh; i++)
{
aliases[i + aliasOffset].SetValue(vector[i + vectorOffset]);
}
}
/// <summary>
/// Gets aliases names linked to data consumer
/// </summary>
/// <param name="consumer">The data consumer</param>
/// <param name="desktop">Relative desktop</param>
/// <param name="l">List of name of aliases</param>
/// <param name="type">Type of alias</param>
public static void GetAliases(this IDataConsumer consumer, IDesktop desktop, IList<string> l, object type)
{
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
if (m is IAlias)
{
IAlias a = m as IAlias;
if (a is IAssociatedObject)
{
IAssociatedObject ao = a as IAssociatedObject;
object o = ao.Object;
if (o != null)
{
if (o is INamedComponent)
{
INamedComponent nc = o as INamedComponent;
string n = nc.GetName(desktop);
IList<string> an = a.AliasNames;
foreach (string aname in an)
{
string s = n + "." + aname;
object t = a.GetType(aname);
if (type != null)
{
if (!type.Equals(t))
{
continue;
}
}
if (!l.Contains(s))
{
l.Add(s);
}
}
}
}
}
}
if (m is IDataConsumer)
{
IDataConsumer cons = m as IDataConsumer;
GetAliases(cons, desktop, l, type);
}
}
}
/// <summary>
/// Gets aliases names linked to data consumer
/// </summary>
/// <param name="consumer">The data consumer</param>
/// <param name="desktop">Relative desktop</param>
/// <param name="l">List of name of aliases</param>
/// <param name="type">Type of alias</param>
public static void GetAllAliases(this IDataConsumer consumer, IDesktop desktop, IList<string> l, object type)
{
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
if (m is IAliasBase)
{
IAliasBase a = m as IAliasBase;
if (a is IAssociatedObject)
{
IAssociatedObject ao = a as IAssociatedObject;
object o = ao.Object;
if (o != null)
{
if (o is INamedComponent)
{
INamedComponent nc = o as INamedComponent;
string n = nc.GetName(desktop);
if (a is IAlias)
{
IAlias al = a as IAlias;
IList<string> an = al.AliasNames;
foreach (string aname in an)
{
string s = n + "." + aname;
object t = al.GetType(aname);
if (type != null)
{
if (!type.Equals(t))
{
continue;
}
}
if (!l.Contains(s))
{
l.Add(s);
}
}
}
if (a is IAliasVector)
{
IAliasVector av = a as IAliasVector;
IList<string> an = av.AliasNames;
foreach (string aname in an)
{
string s = n + "." + aname;
object t = av.GetType(aname);
if (type != null)
{
if (!type.Equals(t))
{
continue;
}
}
if (!l.Contains(s))
{
l.Add(s);
}
}
}
}
}
}
}
if (m is IDataConsumer)
{
IDataConsumer cons = m as IDataConsumer;
GetAllAliases(cons, desktop, l, type);
}
}
}
/// <summary>
/// Gets list of names measurements of data consumer
/// </summary>
/// <param name="consumer">The data consumer</param>
/// <param name="type">The type of measurements</param>
/// <returns>The list of names measurements</returns>
static public List<string> GetAllMeasurements(this IDataConsumer consumer, object type)
{
List<string> list = new List<string>();
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
IAssociatedObject ao = m as IAssociatedObject;
IAssociatedObject th = consumer as IAssociatedObject;
string on = th.GetRelativeName(ao) + ".";
for (int j = 0; j < m.Count; j++)
{
IMeasure mea = m[j];
string s = on + mea.Name;
if (type == null)
{
list.Add(s);
continue;
}
if (mea.Type.Equals(type))
{
list.Add(s);
}
}
}
return list;
}
/// <summary>
/// Gets all measurements names of consumer
/// </summary>
/// <param name="consumer">The consumer</param>
/// <param name="desktop">Relative desktop</param>
/// <param name="type">Type of measurement</param>
/// <returns>List of names of measurements</returns>
static public List<string> GetAllMeasurements(this IDataConsumer consumer, IDesktop desktop, object type)
{
List<string> list = new List<string>();
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
IAssociatedObject ao = m as IAssociatedObject;
INamedComponent nc = ao.Object as INamedComponent;
string on = nc.GetName(desktop) + ".";
for (int j = 0; j < m.Count; j++)
{
IMeasure mea = m[j];
string s = on + mea.Name;
if (type == null)
{
list.Add(s);
continue;
}
if (mea.Type.Equals(type))
{
list.Add(s);
}
}
}
return list;
}
/// <summary>
/// Gets measures type
/// </summary>
/// <param name="consumer">Consumer</param>
/// <returns>Dictionary of types</returns>
public static Dictionary<string, object> GetAllMeasuresType(this IDataConsumer consumer)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
string on = consumer.GetMeasurementName(m);
for (int j = 0; j < m.Count; j++)
{
IMeasure mea = m[j];
string s = on + "." + mea.Name;
dictionary[s] = mea.Type;
}
}
return dictionary;
}
/// <summary>
/// Gets all measures of defined type
/// </summary>
/// <param name="consumer">Consumer</param>
/// <param name="type">Type</param>
/// <returns>List of measures</returns>
public static IList<string> GetAllMeasuresType(this IDataConsumer consumer, object type)
{
Dictionary<string, object> d = GetAllMeasuresType(consumer);
List<string> l = new List<string>();
foreach (string s in d.Keys)
{
if (type == null)
{
l.Add(s);
continue;
}
if (type.Equals(d[s]))
{
l.Add(s);
}
}
return l;
}
/// <summary>
/// Gets all aliases of consumer and all its children
/// </summary>
/// <param name="consumer">The consumer</param>
/// <param name="list">List of aliases</param>
/// <param name="type">Type of alias</param>
public static void GetAliases(this IDataConsumer consumer, List<string> list, object type)
{
getAliases(consumer, consumer, list, type);
}
/// <summary>
/// Gets all type aliases of consumer and all its children
/// </summary>
/// <param name="consumer">The consumer</param>
/// <param name="list">List of aliases</param>
/// <param name="type">Type of alias</param>
public static void GetAllAliases(this IDataConsumer consumer, List<string> list, object type)
{
getAllAliases(consumer, consumer, list, type);
}
/// <summary>
/// Gets all aliases of data consumer
/// </summary>
/// <param name="consumer">The consumer</param>
/// <param name="type">Type of alias</param>
/// <returns>List of aliases</returns>
public static List<string> GetAliases(this IDataConsumer consumer, object type)
{
List<string> list = new List<string>();
GetAliases(consumer, list, type);
return list;
}
/// <summary>
/// Gets list children measurements of data consumer
/// </summary>
/// <param name="consumer">The consumer</param>
/// <param name="measurements">Children measurements</param>
public static void GetMeasurements(this IDataConsumer consumer, List<IMeasurements> measurements)
{
if (consumer is IChildrenObject)
{
IChildrenObject co = consumer as IChildrenObject;
IAssociatedObject[] aob = co.Children;
foreach (object o in aob)
{
if (o is IDataConsumer)
{
GetMeasurements(o as IDataConsumer, measurements);
}
else if (o is IMeasurements)
{
IMeasurements mc = o as IMeasurements;
if (!measurements.Contains(mc))
{
measurements.Add(mc);
}
}
}
}
if (consumer is IMeasurements)
{
IMeasurements m = consumer as IMeasurements;
if (!measurements.Contains(m))
{
measurements.Add(m);
}
}
for (int i = 0; i < consumer.Count; i++)
{
object o = consumer[i];
if (o is IDataConsumer)
{
IDataConsumer c = o as IDataConsumer;
GetMeasurements(c, measurements);
}
else if (o is IMeasurements)
{
IMeasurements m = o as IMeasurements;
if (!(measurements.Contains(m)))
{
measurements.Add(m);
}
}
List<IMeasurements> lm = new List<IMeasurements>(measurements);
List<IMeasurements> proh = new List<IMeasurements>();
foreach (IMeasurements m in lm)
{
if (m is DataPerformer.Interfaces.IBlocking)
{
DataPerformer.Interfaces.IBlocking b = m as DataPerformer.Interfaces.IBlocking;
if (b.Blocked)
{
proh.Add(m);
}
}
}
int count = 0;
List<IMeasurements> add = new List<IMeasurements>(proh);
while (true)
{
foreach (IMeasurements m in measurements)
{
if (m is IDataConsumer)
{
IDataConsumer dc = m as IDataConsumer;
for (int j = 0; j < dc.Count; j++)
{
IMeasurements mea = dc[j];
if (proh.Contains(mea))
{
if (!add.Contains(m))
{
add.Add(m);
}
break;
}
}
}
}
if (count == proh.Count)
{
break;
}
proh = add;
count = proh.Count;
}
foreach (IMeasurements m in proh)
{
if (measurements.Contains(m))
{
measurements.Remove(m);
}
}
}
}
/// <summary>
/// Resets updated measurements
/// </summary>
/// <param name="collection">The collection</param>
public static void ResetUpdatedMeasurements(this IComponentCollection collection)
{
collection.ForEach<IMeasurements>((IMeasurements m) => { m.IsUpdated = false; });
}
/// <summary>
/// Gets data consumers of desktop
/// </summary>
/// <param name="desktop">The desktop</param>
/// <returns>Consumers</returns>
public static List<IDataConsumer> GetDataConsumers(this IComponentCollection desktop)
{
return GetDataConsumers(desktop.AllComponents);
}
/// <summary>
/// Gets data consumers of collection
/// </summary>
/// <param name="collection">The collectionp</param>
/// <returns>Consumers</returns>
public static List<IDataConsumer> GetDataConsumers(this ICollection<object> collection)
{
List<IDataConsumer> list = new List<IDataConsumer>();
foreach (object o in collection)
{
if (!(o is IObjectLabel))
{
continue;
}
IObjectLabel l = o as IObjectLabel;
object ob = l.Object;
if (!(ob is IDataConsumer))
{
continue;
}
IDataConsumer c = ob as IDataConsumer;
list.Add(c);
}
return list;
}
/// <summary>
/// Gets dependent objects of data consumer
/// </summary>
/// <param name="consumer">The data consumer</param>
/// <param name="list">List of dependent objects</param>
public static void GetDependentObjects(this IDataConsumer consumer, IList list)
{
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
if (!list.Contains(m))
{
list.Add(m);
}
if (m is IDataConsumer)
{
IDataConsumer c = m as IDataConsumer;
GetDependentObjects(c, list);
}
}
}
/// <summary>
/// Gets dependent objects of data consumer
/// </summary>
/// <param name="consumer">The data consumer</param>
/// <returns>List of dependent objects</returns>
public static IList GetDependentObjects(this IDataConsumer consumer)
{
ArrayList l = new ArrayList();
GetDependentObjects(consumer, l);
return l;
}
/// <summary>
/// Gets dependent collection
/// </summary>
/// <param name="consumer">Consumer</param>
/// <param name="priority">Priority</param>
/// <returns>Dependent collection</returns>
public static IComponentCollection GetDependentCollection(this IDataConsumer consumer, int priority)
{
return StaticExtension.Factory.CreateCollection(consumer, priority);
}
/// <summary>
/// Finds Alias name object
/// </summary>
/// <param name="consumer">Consumer</param>
/// <param name="alias">Name of alias</param>
/// <param name="allowNulls">The "allow nulls" sign</param>
/// <returns>The AliasName object</returns>
public static AliasName FindAliasName(this IDataConsumer consumer, string alias, bool allowNulls)
{
if (alias == null)
{
if (allowNulls)
{
throw new Exception("Null alias is not accepted");
}
return null;
}
IAssociatedObject ao = consumer as IAssociatedObject;
INamedComponent nc = ao.Object as INamedComponent;
return FindAliasName(consumer, nc.Desktop, alias);
}
/// <summary>
/// Finds alias by name
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="alias">Alias name</param>
/// <param name="allowNulls">The "allow nulls" sign</param>
/// <returns>Necessary aliases</returns>
public static IAliasName[] FindAllAliasName(this IDataConsumer consumer, string alias, bool allowNulls)
{
if (alias == null)
{
if (allowNulls)
{
throw new Exception("Null alias is not accepted");
}
return null;
}
IAssociatedObject ao = consumer as IAssociatedObject;
INamedComponent nc = ao.Object as INamedComponent;
return FindAllAliasName(consumer, consumer, alias);
}
/// <summary>
/// Finds aliases
/// </summary>
/// <param name="consumer">Consumer</param>
/// <param name="aliases">Names of aliases</param>
/// <param name="allowNulls">The "allow null" sign</param>
/// <returns>Array of aliases</returns>
public static AliasName[] FindAliases(this IDataConsumer consumer, string[] aliases, bool allowNulls)
{
AliasName[] an = new AliasName[aliases.Length];
for (int i = 0; i < an.Length; i++)
{
string s = aliases[i];
if (s != null)
{
an[i] = FindAliasName(consumer, s, allowNulls);
}
}
return an;
}
/// <summary>
/// Finds alias
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="desktop">Desktop</param>
/// <param name="alias">Alias name</param>
/// <returns>Alias</returns>
public static AliasName FindAliasName(this IDataConsumer consumer, IDesktop desktop, string alias)
{
object[] o = FindAlias(consumer, desktop, alias);
if (o == null)
{
return null;
}
return new AliasName(o[0] as IAlias, o[1] as string); ;
}
/// <summary>
/// Find aliases
/// </summary>
/// <param name="baseObject">Base object</param>
/// <param name="consumer">Consumer</param>
/// <param name="alias">Alias name</param>
/// <returns>All alias name objects</returns>
public static IAliasName[] FindAllAliasName(this IDataConsumer baseObject, IDataConsumer consumer, string alias)
{
if (consumer != baseObject)
{
IAliasName[] an = FindAllAliasObjectName(baseObject, consumer, alias);
if (an != null)
{
return an;
}
}
for (int i = 0; i < consumer.Count; i++)
{
object o = consumer[i];
if (o is IDataConsumer)
{
IAliasName[] res = FindAllAliasName(baseObject, o as IDataConsumer, alias);
if (res != null)
{
return res;
}
}
IAliasName[] an = FindAllAliasObjectName(baseObject, o, alias);
if (an != null)
{
return an;
}
}
return null;
}
/// <summary>
/// Finds all aliases
/// </summary>
/// <param name="baseObject">Base object</param>
/// <param name="o">Current object</param>
/// <param name="alias">Alias name</param>
/// <returns>All aliases</returns>
public static IAliasName[] FindAllAliasObjectName(this IDataConsumer baseObject, object o, string alias)
{
IAssociatedObject asc = baseObject as IAssociatedObject;
if (o is MeasurementsWrapper)
{
MeasurementsWrapper mw = o as MeasurementsWrapper;
for (int i = 0; i < mw.Count; i++)
{
IAliasName[] an = FindAllAliasObjectName(baseObject, mw[i], alias);
if (an != null)
{
return an;
}
}
}
if (o is IAliasBase)
{
IAliasBase ab = o as IAliasBase;
if (o is IAssociatedObject)
{
IAssociatedObject ao = o as IAssociatedObject;
if (ao.Object != null)
{
if (ao.Object is INamedComponent)
{
IAlias al = AliasWrapper.GetAlias(ao);
if (al != null)
{
string n = asc.GetRelativeName(ao);
IList<string> l = al.AliasNames;
foreach (string an in l)
{
string s = n + "." + an;
if (s.Equals(alias))
{
return new IAliasName[] { new AliasName(al, an) };
}
}
}
if (ab is IAliasVector)
{
IAliasVector av = ab as IAliasVector;
string n = asc.GetRelativeName(ao);
IList<string> l = av.AliasNames;
foreach (string an in l)
{
string s = n + "." + an;
if (s.Equals(alias))
{
List<IAliasName> list = new List<IAliasName>();
int count = av.GetCount(an);
for (int j = 0; j < count; j++)
{
list.Add(new AliasNameVector(av, an, j));
}
return list.ToArray();
}
}
}
}
}
}
}
return null;
}
/// <summary>
/// Finds alias by name
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="desktop">Desktop</param>
/// <param name="alias">Alias name</param>
/// <returns>Alias</returns>
public static object[] FindAlias(this IDataConsumer consumer, IDesktop desktop, string alias)
{
for (int i = 0; i < consumer.Count; i++)
{
object o = consumer[i];
if (o is IAssociatedObject)
{
IAssociatedObject ao = o as IAssociatedObject;
IAlias al = AliasWrapper.GetAlias(ao);
if (al != null)
{
if (ao.Object != null)
{
if (ao.Object is INamedComponent)
{
INamedComponent nc = ao.Object as INamedComponent;
string n = nc.Name;
IList<string> l = al.AliasNames;
foreach (string an in l)
{
string s = n + "." + an;
if (s.Equals(alias))
{
return new object[] { al, an };
}
}
}
}
}
}
if (o is IDataConsumer)
{
IDataConsumer c = o as IDataConsumer;
object[] r = FindAlias(c, desktop, alias);
if (r != null)
{
return r;
}
}
}
return null;
}
/// <summary>
/// Gets priority of object
/// </summary>
/// <param name="obj">The object</param>
/// <returns>The priority</returns>
public static int GetPriority(this object obj)
{
object[] coll = obj.GetObjects();
int p = 0;
foreach (object o in coll)
{
int i = o.GetCalculationPriority();
if (i > p)
{
p = i;
}
}
return p;
}
/// <summary>
/// Finds alias object
/// </summary>
/// <param name="baseObject">Base object</param>
/// <param name="consumer">Data consumer</param>
/// <param name="alias">Full alias</param>
/// <returns>Pair objec[]{object, alias}</returns>
public static object[] findAlias(this IDataConsumer baseObject, IDataConsumer consumer, string alias)
{
IAssociatedObject ao = baseObject as IAssociatedObject;
INamedComponent nc = PureObjectLabel.PrefixComponent(ao, consumer, alias);
if ((nc != null) & (consumer is IAliasBase))
{
return new object[] { consumer, PureObjectLabel.Suffix(alias) };
}
for (int i = 0; i < consumer.Count; i++)
{
object o = consumer[i];
if (o is IDataConsumer)
{
IDataConsumer c = o as IDataConsumer;
object[] r = findAlias(baseObject, c, alias);
if (r != null)
{
return r;
}
}
else
{
INamedComponent comp = PureObjectLabel.PrefixComponent(ao, o, alias);
if ((comp != null) & (o is IAlias))
{
IAlias al = o as IAlias;
if (o is IAssociatedObject)
{
IAssociatedObject aso = o as IAssociatedObject;
al = AliasWrapper.GetAlias(aso);
}
return new object[] { al, PureObjectLabel.Suffix(alias) };
}
}
}
return null;
}
/// <summary>
/// Gets name of measure
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="measure">Measure</param>
/// <returns>The name</returns>
public static string GetName(this IDataConsumer consumer, IMeasure measure)
{
IAssociatedObject ass = consumer as IAssociatedObject;
INamedComponent comp = ass.Object as INamedComponent;
IDesktop d = comp.Desktop;
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements mea = consumer[i];
for (int j = 0; j < mea.Count; j++)
{
IMeasure m = mea[j];
if (m == measure)
{
IAssociatedObject ao = mea as IAssociatedObject;
INamedComponent nc = ao.Object as INamedComponent;
string name = PureObjectLabel.GetName(nc, d);
return name + "." + m.Name;
}
}
}
return null;
}
/// <summary>
/// Finds measure
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="measure">Measure name</param>
/// <param name="allowNull">The allow null sign</param>
/// <returns>The measure</returns>
public static IMeasure FindMeasure(this IDataConsumer consumer, string measure, bool allowNull)
{
if (measure == null)
{
if (!allowNull)
{
throw new Exception("Undefined measure");
}
return null;
}
int n = measure.LastIndexOf(".");
if (n < 0)
{
if (!allowNull)
{
throw new Exception("Undefined measure");
}
return null;
}
string p = measure.Substring(0, n);
string s = measure.Substring(n + 1);
IAssociatedObject ass = consumer as IAssociatedObject;
INamedComponent comp = ass.Object as INamedComponent;
IDesktop d = comp.Desktop;
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements mea = consumer[i];
IAssociatedObject ao = mea as IAssociatedObject;
INamedComponent nc = ao.Object as INamedComponent;
string name = PureObjectLabel.GetName(nc, d);
if (!name.Equals(p))
{
continue;
}
for (int j = 0; j < mea.Count; j++)
{
IMeasure m = mea[j];
if (s.Equals(m.Name))
{
return m;
}
}
}
return null;
}
/// <summary>
/// Find measurements of consumer by strings
/// </summary>
/// <param name="consumer">Consumer</param>
/// <param name="measures">String representation of measures</param>
/// <param name="allowNulls">The "allow nulls" flag</param>
/// <returns>Array of measures</returns>
static public IMeasure[] FindMeasures(this IDataConsumer consumer, string[] measures, bool allowNulls)
{
IMeasure[] m = new IMeasure[measures.Length];
for (int i = 0; i < m.Length; i++)
{
string s = measures[i];
if (s != null)
{
m[i] = FindMeasure(consumer, measures[i], allowNulls);
}
}
return m;
}
/// <summary>
/// Finds alias object
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="alias">Full alias</param>
/// <returns>Pair object[]{object, alias}</returns>
public static object[] FindAlias(this IDataConsumer consumer, string alias)
{
if (alias == null)
{
return null;
}
return findAlias(consumer, consumer, alias);
}
/// <summary>
/// Gets relative name
/// </summary>
/// <param name="o">Base object</param>
/// <param name="mea">Measurements</param>
/// <returns>The name</returns>
public static string GetName(this IAssociatedObject o, IMeasurements mea)
{
IAssociatedObject ao = mea as IAssociatedObject;
return o.GetRelativeName(ao);
}
/// <summary>
/// Gets relative name of measurement
/// </summary>
/// <param name="dc">Data consumer of measurement</param>
/// <param name="mea">Source of measurement</param>
/// <returns>Relative name</returns>
public static string GetMeasurementName(this IDataConsumer dc, IMeasurements mea)
{
IAssociatedObject ao = dc as IAssociatedObject;
return ao.GetName(mea);
}
/// <summary>
/// Updates measurements
/// </summary>
/// <param name="measurements">Measurements</param>
/// <param name="recursive">Recursive sign</param>
public static void UpdateMeasurements(this IMeasurements measurements, bool recursive)
{
measurements.IsUpdated = false;
if (recursive)
{
if (measurements is IDataConsumer)
{
IDataConsumer cons = measurements as IDataConsumer;
int n = cons.Count;
for (int i = 0; i < n; i++)
{
UpdateMeasurements(cons[i], recursive);
}
}
}
measurements.UpdateMeasurements();
}
/// <summary>
/// Sets time provider to data consumer and all dependent objects
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="provider">Data provider</param>
/// <returns>Backup dictionary</returns>
private static IDictionary<ITimeMeasureConsumer, IMeasure> SetTimeProvider(this IDataConsumer consumer, ITimeMeasureProvider provider)
{
Dictionary<ITimeMeasureConsumer, IMeasure> dictionary = new Dictionary<ITimeMeasureConsumer, IMeasure>();
SetTimeProvider(consumer, provider, dictionary);
return dictionary;
}
/// <summary>
/// Sets time provider to data consumer and all dependent objects
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="provider">Data provider</param>
/// <param name="dictionary">Backup dictionary</param>
private static void SetTimeProvider(this IDataConsumer consumer, ITimeMeasureProvider provider, IDictionary<ITimeMeasureConsumer, IMeasure> dictionary)
{
if (consumer is ITimeMeasureConsumer)
{
ITimeMeasureConsumer tc = consumer as ITimeMeasureConsumer;
if (dictionary.ContainsKey(tc))
{
if (tc.Time != provider.TimeMeasure)
{
dictionary[tc] = tc.Time;
tc.Time = provider.TimeMeasure;
}
}
else
{
dictionary[tc] = tc.Time;
tc.Time = provider.TimeMeasure;
}
}
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
if (m is ITimeMeasureConsumer)
{
ITimeMeasureConsumer mc = m as ITimeMeasureConsumer;
if (dictionary.ContainsKey(mc))
{
if (mc.Time != provider.TimeMeasure)
{
dictionary[mc] = mc.Time;
mc.Time = provider.TimeMeasure;
}
}
else
{
dictionary[mc] = mc.Time;
mc.Time = provider.TimeMeasure;
}
}
if (m is IDataConsumer)
{
IDataConsumer dc = m as IDataConsumer;
SetTimeProvider(dc, provider, dictionary);
}
}
}
/// <summary>
/// Updates measurements
/// </summary>
/// <param name="measurements">Measurements</param>
/// <param name="recursive">Recursive sign</param>
public static void UpdateMeasurements(this ICollection<IMeasurements> measurements, bool recursive)
{
foreach (IMeasurements m in measurements)
{
m.UpdateMeasurements(recursive);
}
}
/// <summary>
/// Resets data consumer and all depenent objects
/// </summary>
/// <param name="consumer">The consumer</param>
public static void FullReset(this IDataConsumer consumer)
{
if (consumer is IMeasurements)
{
IMeasurements mea = consumer as IMeasurements;
mea.IsUpdated = false;
}
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i] as IMeasurements;
m.IsUpdated = false;
if (m is IDataConsumer)
{
IDataConsumer c = m as IDataConsumer;
c.Reset();
}
}
}
/// <summary>
/// Gets root desktop of consumer
/// </summary>
/// <param name="consumer">The consumer</param>
/// <returns>The desktop</returns>
public static IDesktop GetRootConsumerDesktop(this IDataConsumer consumer)
{
ICategoryObject ob = consumer as ICategoryObject;
return ob.GetRootDesktop();
}
/// <summary>
/// Prepares consumer
/// </summary>
/// <param name="consumer">Consumer for preparation</param>
static public void Prepare(this IDataConsumer consumer)
{
consumer.FullReset();
consumer.UpdateChildrenData();
}
/// <summary>
/// Time
/// </summary>
public static double Time
{
get
{
return StaticExtension.Factory.TimeProvider.Time;
}
set
{
StaticExtension.Factory.TimeProvider.Time = value;
}
}
/// <summary>
/// Gets all iterators of consumer
/// </summary>
/// <param name="consumer">Consumer</param>
/// <param name="iterators">List of iterators</param>
public static void GetIterators(this IDataConsumer consumer, List<IIterator> iterators)
{
getIterators(consumer, iterators);
}
/// <summary>
/// Gets all measurements of one dimension real array
/// </summary>
/// <param name="ao">Associated object</param>
/// <returns>Names of measurements</returns>
public static string[] GetOneDimensionRealArrays(this IAssociatedObject ao)
{
INamedComponent nc = null;
if (ao is INamedComponent)
{
nc = ao as INamedComponent;
}
else
{
nc = ao.Object as INamedComponent;
}
IDesktop desktop = nc.Root.Desktop;
if (desktop == null)
{
desktop = nc.Desktop;
}
if (desktop == null)
{
return new string[0];
}
List<string> l = new List<string>();
desktop.ForEach<IMeasurements>((IMeasurements m) =>
{
IAssociatedObject aob = m as IAssociatedObject;
INamedComponent ncm = aob.Object as INamedComponent;
string nm = ncm.GetName(desktop);
for (int i = 0; i < m.Count; i++)
{
IMeasure mea = m[i];
if (mea == null)
{
continue;
}
object t = mea.Type;
if (!(t is ArrayReturnType))
{
continue;
}
ArrayReturnType art = t as ArrayReturnType;
Double a = 0;
if (!art.ElementType.Equals(a))
{
continue;
}
if (art.Dimension.Length != 1)
{
continue;
}
l.Add(nm + "." + mea.Name);
}
});
return l.ToArray();
}
/// <summary>
/// Gets one dimensional array by name
/// </summary>
/// <param name="ao">Associated object</param>
/// <param name="name">Full name of array</param>
/// <returns>The array</returns>
public static Array GetOneDimensionRealArray(this IAssociatedObject ao, string name)
{
INamedComponent nc = null;
if (ao is INamedComponent)
{
nc = ao as INamedComponent;
}
else
{
nc = ao.Object as INamedComponent;
}
IDesktop desktop = nc.Root.Desktop;
Array arr = null;
desktop.ForEach<IMeasurements>((IMeasurements m) =>
{
IAssociatedObject aob = m as IAssociatedObject;
INamedComponent ncm = aob.Object as INamedComponent;
string nm = ncm.GetName(desktop);
for (int i = 0; i < m.Count; i++)
{
try
{
IMeasure mea = m[i];
if (mea == null)
{
continue;
}
string nn = nm + "." + mea.Name;
if (name.Equals(nn))
{
if (arr != null)
{
ao.Throw("Ambigous");
}
arr = mea.Parameter() as Array;
break;
}
}
catch (Exception ex)
{
ex.Log();
}
}
});
return arr;
}
/// <summary>
/// Gets variables form collection
/// </summary>
/// <param name="collection">The collection</param>
/// <returns>The variables</returns>
public static List<string[]> GetDoubleVariables(this IComponentCollection collection)
{
List<string[]> l = new List<string[]>();
Action<IStateDoubleVariables> action = (IStateDoubleVariables v) =>
{
object o = v;
string n = o.GetName(collection);
List<string> ll = v.Variables;
foreach (string ss in ll)
{
l.Add(new string[] { n, ss });
}
};
collection.ForEach<IStateDoubleVariables>(action);
return l;
}
/// <summary>
/// Gets state vector of collection
/// </summary>
/// <param name="collection">The collection</param>
/// <param name="output">The state vector</param>
public static void GetStateVector(this IComponentCollection collection, double[] output)
{
int i = 0;
Action<IStateDoubleVariables> action = (IStateDoubleVariables v) =>
{
double[] x = v.Vector;
int n = x.Length;
Array.Copy(x, 0, output, i, n);
i += n;
};
collection.ForEach<IStateDoubleVariables>(action);
}
/// <summary>
/// Gets state vector of collection
/// </summary>
/// <param name="collection">The collection</param>
/// <param name="input">The state vector</param>
public static void SetStateVector(this IComponentCollection collection, double[] input)
{
int i = 0;
Action<IStateDoubleVariables> action = (IStateDoubleVariables v) =>
{
double[] x = v.Vector;
int n = x.Length;
v.Set(input, i, x.Length);
i += n;
};
collection.ForEach<IStateDoubleVariables>(action);
}
/// <summary>
/// Gets count of variables
/// </summary>
/// <param name="processor">Processor</param>
/// <returns>Variables</returns>
static public int GetVariablesCount(this IDifferentialEquationSolver processor)
{
return processor.Variables.Count;
}
/// <summary>
/// Sets collection
/// </summary>
/// <param name="processor">The processor</param>
/// <param name="collection">The colletion</param>
/// <returns>List of variables</returns>
static public void Set(this IDifferentialEquationProcessor processor, IComponentCollection collection)
{
processor.Set(collection);
}
#endregion
#region Private Members
static void getIterators(IDataConsumer consumer, List<IIterator> list)
{
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
if (m is IIterator)
{
IIterator it = m as IIterator;
if (!list.Contains(it))
{
list.Add(it);
}
}
if (m is IDataConsumer)
{
IDataConsumer c = m as IDataConsumer;
getIterators(c, list);
}
}
}
private static void getAliases(this IDataConsumer baseObject, IDataConsumer consumer, List<string> list, object type)
{
IAssociatedObject ao = baseObject as IAssociatedObject;
PureObjectLabel.GetObjectAliases(ao, consumer, list, type);
for (int i = 0; i < consumer.Count; i++)
{
object o = consumer[i];
if (o is IDataConsumer)
{
IDataConsumer c = o as IDataConsumer;
getAliases(baseObject, c, list, type);
}
else
{
PureObjectLabel.GetObjectAliases(ao, o, list, type);
}
}
}
private static void getAllAliases(this IDataConsumer baseObject, IDataConsumer consumer, List<string> list, object type)
{
IAssociatedObject ao = baseObject as IAssociatedObject;
PureObjectLabel.GetObjectAliases(ao, consumer, list, type);
for (int i = 0; i < consumer.Count; i++)
{
object o = consumer[i];
if (o is IDataConsumer)
{
IDataConsumer c = o as IDataConsumer;
getAllAliases(baseObject, c, list, type);
}
else
{
PureObjectLabel.GetAllObjectAliases(ao, o, list, type);
}
}
}
#endregion
}
}
Submit an article or tip