public ValidationInfo()
{
for (int i = EditsMaxCount; --i >= 0;)
{
ElementNames.Add(string.Empty);
}
}
internal void AddText(string text, float x, float y, ElementNames element, int ttl, Vector4 color, Justify justify = Justify.None, FontType fontType = FontType.Mono, float fontSize = 10f, float heightScale = 0.65f)
{
AgingTextures = true;
AgingTextRequest request;
if (_agingTextRequests.TryGetValue(element, out request))
{
request.RefreshTtl(ttl);
return;
}
request = _agingTextRequestPool.Get();
var pos = GetScreenSpace(new Vector2(x, y));
request.Text = text;
request.Color = color;
request.Position.X = pos.X;
request.Position.Y = pos.Y;
request.FontSize = fontSize * MetersInPixel;
request.Font = fontType;
request.Ttl = ttl;
request.Type = element;
request.Justify = justify;
request.HeightScale = heightScale;
_agingTextRequests.TryAdd(element, request);
}
static Commons()
{
foreach (var item in ElementTable)
{
ElementNames.Add(item.Name);
ElementSymbols.Add(item.ChemicalSymbol);
ElementNumber.Add(item.AtomicNumber);
}
}
/// <summary>
/// Gets the name of special element.
/// </summary>
public override string GetName(ElementNames type)
{
switch (type)
{
case ElementNames.DefaultValid:
case ElementNames.AsVariable:
return(variable.Name);
default:
return(null);
}
}
/// <summary>
/// Gets the name of special element.
/// </summary>
public override string GetName(ElementNames type)
{
switch (type)
{
case ElementNames.DefaultValid:
case ElementNames.AsProperty:
return(property.Name);
default:
return(null);
}
}
private void CheckExists(string elementName)
{
GetElementNames = GetElementTypesAction();
var isExists = GetElementNames().Contains(elementName);
if (isExists)
{
throw new Exception($"Element with the name {elementName} already exists");
}
ElementName = elementName;
}
private static void Report(SyntaxNodeAnalysisContext context, DiagnosticDescriptor diagnostic,
Location location, string elemIdent)
{
string elemName;
if (!ElementNames.TryGetValue(context.Node.Kind(), out elemName))
{
elemName = "UNKNOWN";
}
context.ReportDiagnostic(
Diagnostic.Create(diagnostic, location, elemName, elemIdent)
);
}
public void Pack(char productType, char loggerType)
{
try
{
var logger = _container.Resolve <ILogger>(ElementNames.GetLoggerName(loggerType));
var product = _container.Resolve <IProduct>(ElementNames.GetProductTypeName(productType));
product.Pack(logger);
ConfirmSuccess();
}
catch (Exception e)
{
InformFail(e.Message);
}
}
public static string GetIsotopeFile(string name, int A, FILETYP ftype)
{
string rtyp = FileTypeDir[ftype] + FileTypeName[ftype];
var z = ElementNames.ToList().IndexOf(name);
if (z == -1)
{
return(string.Empty);
}
string sz = z.ToString("D3");
string sa = A.ToString("D3");
string filePath = rtyp + sz + "_" + ElementNames[z] + "_" + sa + ".endf";
return(RootDir + filePath);
}
public TypeSe(ElementNames.Name elementName)
{
Element = elementName;
ElementTagLookUp = new Dictionary<ElementNames.Name, string>
{
{ ElementNames.Name.Button, "input" },
{ ElementNames.Name.CheckBox, "input" },
{ ElementNames.Name.Div, "div" },
{ ElementNames.Name.Image, "img" },
{ ElementNames.Name.Label, "label" },
{ ElementNames.Name.Link, "a" },
{ ElementNames.Name.RadioButton, "input" },
{ ElementNames.Name.SelectList, "select" },
{ ElementNames.Name.Span, "span" },
{ ElementNames.Name.TableBody, "tbody" },
{ ElementNames.Name.TableCell, "td" },
{ ElementNames.Name.TableHead, "thead" },
{ ElementNames.Name.TableRow, "tr" },
{ ElementNames.Name.Table, "table" },
{ ElementNames.Name.TextField, "input" },
};
ElementTypeLookUp = new Dictionary<ElementNames.Name, string>
{
{ ElementNames.Name.Button, "button" },
{ ElementNames.Name.CheckBox, "checkbox" },
{ ElementNames.Name.Div, string.Empty },
{ ElementNames.Name.Image, string.Empty },
{ ElementNames.Name.Label, string.Empty },
{ ElementNames.Name.Link, string.Empty },
{ ElementNames.Name.RadioButton, "radio" },
{ ElementNames.Name.SelectList, string.Empty },
{ ElementNames.Name.Span, string.Empty },
{ ElementNames.Name.TableBody, string.Empty },
{ ElementNames.Name.TableCell, string.Empty },
{ ElementNames.Name.TableHead, string.Empty },
{ ElementNames.Name.TableRow, string.Empty },
{ ElementNames.Name.Table, string.Empty },
{ ElementNames.Name.TextField, "text" },
};
}
public ValueInfo()
{
ElementNames.Add(string.Empty);
}
public BindingInfo()
{
ElementNames.Add(string.Empty);
}
public override string ToString()
=> string.Join(" ", ElementNames.Select(x => x.Name)) + " " + Occurrences;
public ElementLayoutInfo()
{
ElementNames.Add(string.Empty);
}
private object GetConsumableElement(ConsumableItem consumableItem, ElementNames elementName)
{
return(consumableItem.Elements.Where(x => x.Name == elementName).Select(z => z.Value).SingleOrDefault());
}
/// <summary> /// Gets the name of special element. /// </summary> public abstract string GetName(ElementNames type);
/// <summary>
/// Parse a HyXML formatted file
///
/// Notes:
/// 1) Assumes guards and invariants are formatted as infix strings (e.g., 5 + x >= y is a valid guard or invariant, whereas (>= (+ 5 x) y) is not)
/// 2) Assumes resets are formatted as: varToReset' = expr
/// 3) Assumes differential inclusions are formatted as: x1_dot >= a and x1_dot <= b; more generally, any relations are okay, we just don't support x1_dot \in [a, b]
///
/// 1) Eventually modify HyLink to generate HyXML using MathML for guards, invariants, and resets
/// </summary>
/// <param name="path"></param>
public static void ParseInputFile(String path)
{
Controller.Instance.Sys = new Holism();
ConcreteHybridAutomaton h = null;
Transition t = null;
ConcreteLocation l = null;
ElementNames n = ElementNames.parameter;
if (!File.Exists(path))
{
throw new FileNotFoundException("Input file not found: " + path);
}
XmlTextReader reader = new XmlTextReader(path);
while (reader.Read())
{
try
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
n = (ElementNames)(Enum.Parse(typeof(ElementNames), reader.Name, true));
switch (n)
{
case ElementNames.parameter:
{
Variable p = ParseVariableParameter(reader);
break;
}
case ElementNames.predicate:
{
break;
}
// since properties can refer to elements of the automata, we save their strings and parse them after all automata have been fully constructed
case ElementNames.property:
{
ParseProperty(reader);
break;
}
case ElementNames.assumption:
{
ParseAssumption(reader);
break;
}
case ElementNames.action:
{
ParseReset(reader, t);
break;
}
case ElementNames.automaton:
{
String name = reader.GetAttribute(AutomatonAttributes.name.ToString());
h = new ConcreteHybridAutomaton(Controller.Instance.Sys, name);
break;
}
case ElementNames.dai:
{
ParseDAI(reader, h, l);
break;
}
case ElementNames.guard:
{
ParseGuard(reader, t);
break;
}
case ElementNames.uguard:
{
if (t == null)
{
throw new System.Exception("Error parsing transition: transition not specified properly before reaching universally quantified guard.");
}
String uguard = reader.GetAttribute(GuardAttributes.equn.ToString());
if (uguard.Length > 0)
{
Antlr.Runtime.Tree.CommonTree tmptree = math.Expression.Parse(uguard);
t.UGuard = LogicalExpression.CreateTerm(tmptree);
}
break;
}
case ElementNames.initial:
{
if (h == null)
{
throw new System.Exception("Error parsing initial: automaton not specified properly before reaching initial.");
}
String init = reader.GetAttribute(InitialAttributes.equn.ToString());
if (init.Length > 0)
{
h.InitialString = init;
}
break;
}
case ElementNames.invariant:
{
if (l == null)
{
throw new System.Exception("Error parsing transition: location not specified properly before reaching invariant.");
}
String inv = reader.GetAttribute(InvariantAttributes.equn.ToString());
if (inv.Length > 0)
{
Antlr.Runtime.Tree.CommonTree tmptree = math.Expression.Parse(inv);
l.Invariant = LogicalExpression.CreateTerm(tmptree);
}
break;
}
case ElementNames.stop:
{
if (l == null)
{
throw new System.Exception("Error parsing transition: location not specified properly before reaching stopping condition.");
}
String stop = reader.GetAttribute(StopAttributes.equn.ToString());
if (stop.Length > 0)
{
Antlr.Runtime.Tree.CommonTree tmptree = math.Expression.Parse(stop);
l.Stop = LogicalExpression.CreateTerm(tmptree);
}
break;
}
case ElementNames.mode:
{
l = ParseLocation(reader, h);
break;
}
case ElementNames.transition:
{
t = ParseTransition(reader, h, l);
break;
}
case ElementNames.variable:
{
ParseVariable(reader, h);
break;
}
case ElementNames.holism:
{
// todo
break;
}
default:
{
throw new Exception("Bad element specified (uncrecognized).");
break;
}
}
break;
}
// destroy temporary arguments
case XmlNodeType.EndElement:
{
n = (ElementNames)(Enum.Parse(typeof(ElementNames), reader.Name, true));
switch (n)
{
case ElementNames.parameter:
{
break;
}
case ElementNames.action:
{
break;
}
case ElementNames.automaton:
{
h.finishConstruction(); // finish building the concrete automaton: create equations for initial conditions, assert constraints on locations, etc.
Controller.Instance.Sys.addHybridAutomaton(h);
foreach (var v in Controller.Instance.Sys.Variables)
{
if (v.UpdateType == Variable.VarUpdateType.discrete && v.Type == Variable.VarType.index)
{
Controller.Instance.Z3.Assumptions.Add(Controller.Instance.Z3.MkLe((ArithExpr)Controller.Instance.IntZero, (ArithExpr)Controller.Instance.GlobalVariables[v.Name]));
Controller.Instance.Z3.Assumptions.Add(Controller.Instance.Z3.MkLe((ArithExpr)Controller.Instance.GlobalVariables[v.Name], (ArithExpr)Controller.Instance.Params["N"]));
Controller.Instance.Z3.Assumptions.Add(Controller.Instance.Z3.MkLe((ArithExpr)Controller.Instance.IntZero, (ArithExpr)Controller.Instance.GlobalVariablesPrimed[v.Name]));
Controller.Instance.Z3.Assumptions.Add(Controller.Instance.Z3.MkLe((ArithExpr)Controller.Instance.GlobalVariablesPrimed[v.Name], (ArithExpr)Controller.Instance.Params["N"]));
}
}
h = null;
break;
}
case ElementNames.dai:
{
break;
}
case ElementNames.guard:
{
break;
}
case ElementNames.invariant:
{
break;
}
case ElementNames.mode:
{
ParseHyXML.ParseLocationEnd(reader, h, l);
l = null;
break;
}
case ElementNames.transition:
{
//l.addTransition(t);
// todo: search the locations by id to find the prestate and poststate locations
t = null;
break;
}
case ElementNames.variable:
{
break;
}
default:
{
break;
}
}
break;
}
default:
{
break;
}
}
}
catch (NoViableAltException ex)
{
System.Console.WriteLine("ERROR: parser error");
System.Console.WriteLine("Line " + reader.LineNumber + " position " + reader.LinePosition + " element name " + reader.Name);
}
catch (Exception ex)
{
System.Console.WriteLine("ERROR: parser error");
System.Console.WriteLine("Line " + reader.LineNumber + " position " + reader.LinePosition + " element name " + reader.Name);
}
}
reader.Close();
}
