private static void ReadTemplateInfoSDCDefinition(ErrorCollector errorCollector, Template.TemplateInfo info, XElement xe)
{
foreach (XElement xeg in xe.Elements())
{
if (xeg.Value == null)
{
continue;
}
switch (GetXEleName(xeg))
{
case "HideZeroObs": info.sdcHideZeroObs = errorCollector.XEleGetBool(xeg, xe); break;
case "MinObsDefault": info.sdcMinObsDefault = errorCollector.XEleGetInt(xeg, xe); break;
case "MinObsAlternatives":
info.sdcMinObsAlternatives = new Dictionary <string, int>(StringComparer.OrdinalIgnoreCase);
foreach (var ele in ReadElementGroup(xeg, ReadSdcMinObsAlternative, errorCollector))
{
if (ele.Key == null)
{
continue;
}
if (info.sdcMinObsAlternatives.ContainsKey(ele.Key))
{
errorCollector.AddDebugOnlyError($"Double definition of SdcMinObsAlternative '{ele.Key}'.");
}
else
{
info.sdcMinObsAlternatives.Add(ele.Key, ele.Value);
}
}
break;
default: errorCollector.AddXmlUnkownEleError(xeg, xe); break;
}
}
}
private static Template.Filter ReadFilter(XElement xeFilter, ErrorCollector errorCollector)
{
Template.Filter filter = new Template.Filter();
foreach (XElement xe in xeFilter.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": filter.name = xe.Value; break;
case "FormulaString": filter.formulaString = xe.Value; break;
case "Reform": filter.reform = errorCollector.XEleGetBool(xe, xeFilter, filter.name); break;
case "Parameters": filter.parameters = ReadElementGroup(xe, ReadParameter, errorCollector); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeFilter, filter.name); break;;
}
}
return(filter);
}
public static bool ParseTemplateInfo(string path, out Template.TemplateInfo templateInfo, out ErrorCollector errorCollector)
{
errorCollector = new ErrorCollector(); templateInfo = new Template.TemplateInfo();
try
{
using (XmlReader xmlReader = XmlReader.Create(path, new XmlReaderSettings()
{
ConformanceLevel = ConformanceLevel.Fragment
}))
{
// first element must always be the TemplateInfo!
while (xmlReader.NodeType != XmlNodeType.Element || xmlReader.Name != "TemplateInfo")
{
if (!xmlReader.Read())
{
errorCollector.AddError("<TemplateInfo> not found!"); return(false);
}
}
XElement xeInfo = XElement.ReadFrom(xmlReader) as XElement;
if (xeInfo == null || xeInfo.Name != "TemplateInfo")
{
errorCollector.AddError("<TemplateInfo> not found!"); return(false);
}
templateInfo = ReadInfo(xeInfo, errorCollector);
return(true); // the only error ReadInfo may produce (except an exception which is caught below) is unknown element, which does no harm
}
}
catch (Exception exception) { errorCollector.AddError(exception.Message); return(false); }
}
private static List <T> ReadElementGroup <T>(XElement xeGroup, Func <XElement, ErrorCollector, T> readFunc, ErrorCollector errorCollector)
{
return(GetElementGroupList(xeGroup.Elements(), // e.g. all elements of <Actions>
GetXEleName(xeGroup).Substring(0, GetXEleName(xeGroup).Length - 1), // e.g. Actions -> Action
readFunc, errorCollector));
}
private static Template.TemplateInfo.UserVariable ReadUserVariable(XElement xeUV, ErrorCollector errorCollector)
{
Template.TemplateInfo.UserVariable uv = new Template.TemplateInfo.UserVariable();
foreach (XElement xe in xeUV.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "UserInputType": uv.inputType = errorCollector.XEleGetEnum <HardDefinitions.UserInputType>(xe, xeUV, uv.name); break;
case "Name": uv.name = xe.Value; break;
case "Description": uv.description = xe.Value; break;
case "Title": uv.title = xe.Value; break;
case "DefaultValue": uv.defaultValue = xe.Value; break;
case "DisplayDescription": uv.displayDescription = errorCollector.XEleGetBool(xe, xeUV, uv.name); break;
case "ComboItems": uv.comboItems = ReadElementGroup(xe, ReadComboItem, errorCollector); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeUV, uv.name); break;
}
}
return(uv);
}
private static DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Legend ReadLegend(XElement xeLegend, ErrorCollector errorCollector)
{
DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Legend legend = new DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Legend();
foreach (XElement xe in xeLegend.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Title": legend.title = xe.Value; break; // not supported in the new presenter!
case "Docking": legend.docking = xe.Value; break;
case "Visible": legend.visible = errorCollector.XEleGetBool(xe, xeLegend); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeLegend); break;
}
}
return(legend);
}
private static DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Axis ReadAxis(XElement xeAxis, ErrorCollector errorCollector)
{
DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Axis axis = new DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Axis();
foreach (XElement xe in xeAxis.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Label": axis.label = xe.Value; break;
case "ValuesFrom": axis.valuesFrom = xe.Value; break;
case "StartFromZero": axis.startFromZero = errorCollector.XEleGetBool(xe, xeAxis); break;
case "Interval": axis.interval = errorCollector.XEleGetInt(xe, xeAxis); break;
case "LabelDocking": axis.labelDocking = xe.Value; break;
default: errorCollector.AddXmlUnkownEleError(xe, xeAxis); break;
}
}
return(axis);
}
private static DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Series ReadGraphSerie(XElement xeSerie, ErrorCollector errorCollector)
{
DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Series serie = new DisplayResults.DisplayPage.DisplayTable.DisplayGraph.Series();
foreach (XElement xe in xeSerie.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Visible": serie.visible = errorCollector.XEleGetBool(xe, xeSerie); break;
case "Name": serie.name = xe.Value; break;
case "Size": serie.size = errorCollector.XEleGetInt(xe, xeSerie); break;
case "Colour": serie.colour = xe.Value; break;
case "Type": serie.type = xe.Value; break;
case "MarkerStyle": serie.markerStyle = xe.Value; break;
default: errorCollector.AddXmlUnkownEleError(xe, xeSerie); break;
}
}
return(serie);
}
private static DisplayResults.DisplayPage.DisplayTable.DisplayGraph ReadGraph(XElement xeGraph, ErrorCollector errorCollector)
{
DisplayResults.DisplayPage.DisplayTable.DisplayGraph graph = new DisplayResults.DisplayPage.DisplayTable.DisplayGraph();
foreach (XElement xe in xeGraph.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "ShowTable": graph.showTable = errorCollector.XEleGetBool(xe, xeGraph); break;
case "SeriesInRows": graph.seriesInRows = errorCollector.XEleGetBool(xe, xeGraph); break;
case "Series": graph.allSeries = ReadElementGroup(xe, ReadGraphSerie, errorCollector); break;
case "Title": graph.title = xe.Value; break;
case "Legend": graph.legend = ReadLegend(xe, errorCollector); break;
case "AxisX": graph.axisX = ReadAxis(xe, errorCollector); break;
case "AxisY": graph.axisY = ReadAxis(xe, errorCollector); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeGraph); break;
}
}
return(graph);
}
private static Template.TemplateInfo.OptionalVariable ReadOptionalVariable(XElement xeOV, ErrorCollector errorCollector)
{
Template.TemplateInfo.OptionalVariable ov = new Template.TemplateInfo.OptionalVariable();
foreach (XElement xe in xeOV.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": ov.name = xe.Value; break;
case "ReadVar": ov.readVar = xe.Value; break;
case "DefaultValue": ov.defaultValue = errorCollector.XEleGetDouble(xe, xeOV, ov.name); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeOV, ov.name); break;
}
}
return(ov);
}
private static Template.TemplateInfo.RequiredVariable ReadRequiredVariable(XElement xeRV, ErrorCollector errorCollector)
{
Template.TemplateInfo.RequiredVariable rv = new Template.TemplateInfo.RequiredVariable();
foreach (XElement xe in xeRV.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": rv.name = xe.Value; break;
case "ReadVar": rv.readVar = xe.Value; break;
default: errorCollector.AddXmlUnkownEleError(xe, xeRV, rv.name); break;
}
}
return(rv);
}
private static Template.TemplateInfo.CalculationLevel ReadCalculationLevel(XElement xeCL, ErrorCollector errorCollector)
{
Template.TemplateInfo.CalculationLevel cl = new Template.TemplateInfo.CalculationLevel();
foreach (XElement xe in xeCL.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": cl.name = xe.Value; break;
case "GroupingVar": cl.groupingVar = xe.Value; break;
default: errorCollector.AddXmlUnkownEleError(xe, xeCL, cl.name); break;
}
}
return(cl);
}
private static KeyValuePair <string, int> ReadSdcMinObsAlternative(XElement xeAlt, ErrorCollector errorCollector)
{
string name = null; int minObs = int.MinValue;
foreach (XElement xe in xeAlt.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": name = xe.Value; break;
case "MinObs": minObs = errorCollector.XEleGetInt(xe, xeAlt); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeAlt); break;
}
}
if (minObs == int.MinValue || name == null)
{
errorCollector.AddDebugOnlyError("Incomplete definition of SdcMinObsAlternative" +
(name == null ? ": missing 'Name'" : $" '{name}': ") +
(minObs == int.MinValue ? "missing 'MinObs'" : string.Empty));
}
return(new KeyValuePair <string, int>(name, minObs));
}
public static bool ParseTemplate(string path, out Template template, out ErrorCollector errorCollector)
{
errorCollector = new ErrorCollector(); template = new Template();
try
{
using (XmlReader xmlReader = XmlReader.Create(path, new XmlReaderSettings()
{
ConformanceLevel = ConformanceLevel.Fragment
}))
{
xmlReader.Read();
while (xmlReader.NodeType != XmlNodeType.None && (xmlReader.NodeType != XmlNodeType.Element || xmlReader.Name != "Template"))
{
xmlReader.Read();
}
if (xmlReader.NodeType == XmlNodeType.None)
{
errorCollector.AddError("Invalid Xml-structure!"); return(false);
}
if (!xmlReader.ReadToDescendant("TemplateInfo"))
{
errorCollector.AddError("<TemplateInfo> not found!"); return(false);
}
XElement infoElement = XElement.ReadFrom(xmlReader) as XElement;
if (infoElement == null || infoElement.Name != "TemplateInfo")
{
errorCollector.AddError("<TemplateInfo>: invalid Xml-structure!"); return(false);
}
template.info = ReadInfo(infoElement, errorCollector);
if (!xmlReader.ReadToNextSibling("Globals"))
{
errorCollector.AddError("<Globals> not found!"); return(false);
}
XElement globalElement = XElement.ReadFrom(xmlReader) as XElement;
if (globalElement == null || globalElement.Name != "Globals")
{
errorCollector.AddError("<Globals>: invalid Xml-structure!"); return(false);
}
foreach (XElement ele in globalElement.Elements())
{
if (ele.Name == "Filters")
{
template.globalFilters = ReadElementGroup(ele, ReadFilter, errorCollector);
}
else if (ele.Name == "Actions")
{
template.globalActions = ReadElementGroup(ele, ReadAction, errorCollector);
}
else
{
errorCollector.AddXmlUnkownEleError(ele, globalElement);
}
}
if (!xmlReader.ReadToNextSibling("Pages"))
{
errorCollector.AddError("<Pages> not found!"); return(false);
}
template.pages = GetElementGroupList(StreamChildElements(xmlReader), "Page", ReadPage, errorCollector);
ReplaceNamedSdcMinObsAlternatives(template.pages, template.info.sdcMinObsAlternatives, errorCollector);
}
return(!errorCollector.HasErrors());
}
catch (Exception exception) { errorCollector.AddError(exception.Message); return(false); }
}
private static void ReplaceNamedSdcMinObsAlternatives(List <Template.Page> pages, Dictionary <string, int> sdcMinObsAlternatives, ErrorCollector errorCollector)
{
foreach (Template.Page page in pages)
{
foreach (Template.Page.Table table in page.tables)
{
if (table.sdcDefinition.minObsAlternative == null && table.sdcDefinition.minObsAlternativeName != null)
{
Replace(ref table.sdcDefinition);
foreach (Template.Page.Table.Row row in table.rows)
{
Replace(ref row.sdcDefinition);
}
foreach (Template.Page.Table.Column column in table.columns)
{
Replace(ref column.sdcDefinition);
}
foreach (Template.Page.Table.Column column in table.reformColumns)
{
Replace(ref column.sdcDefinition);
}
foreach (Template.Page.Table.Cell cell in table.cells)
{
Replace(ref cell.sdcDefinition);
}
foreach (Template.Page.Table.Cell cell in table.reformCells)
{
Replace(ref cell.sdcDefinition);
}
}
}
}
void Replace(ref Template.Page.Table.SDCDefinition sdcDefinition)
{
if (sdcDefinition.minObsAlternativeName == null)
{
return;
}
if (int.TryParse(sdcDefinition.minObsAlternativeName, out int i))
{
sdcDefinition.minObsAlternative = i;
}
else
{
if (sdcMinObsAlternatives.ContainsKey(sdcDefinition.minObsAlternativeName))
{
sdcDefinition.minObsAlternative = sdcMinObsAlternatives[sdcDefinition.minObsAlternativeName];
}
else
{
errorCollector.AddDebugOnlyError($"Unknown SdcMinObsAlternative '{sdcDefinition.minObsAlternativeName}'.");
}
}
}
}