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));
}
private static Template.Parameter ReadParameter(XElement xePar, ErrorCollector errorCollector)
{
Template.Parameter par = new Template.Parameter();
foreach (XElement xe in xePar.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": par.name = xe.Value; break;
case "VarName": par.variableName = xe.Value; break;
case "BoolValue": par.boolValue = errorCollector.XEleGetBool(xe, xePar, par.name); break;
case "NumericValue": par.numericValue = errorCollector.XEleGetDouble(xe, xePar, par.name); break;
case "Reform": par._reform = errorCollector.XEleGetBool(xe, xePar, par.name); break;
default: errorCollector.AddXmlUnkownEleError(xe, xePar, par.name); break;
}
}
return(par);
}
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.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 Template.Action ReadAction(XElement xeAction, ErrorCollector errorCollector)
{
Template.Action action = new Template.Action();
foreach (XElement xe in xeAction.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "CalculationLevel": action._calculationLevel = xe.Value; break;
case "CalculationType": action.calculationType = errorCollector.XEleGetEnum <HardDefinitions.CalculationType>(xe, xeAction); break;
case "OutputVar": action.outputVar = xe.Value; break;
case "FormulaString": action.formulaString = xe.Value; break;
case "Filter": action.filter = ReadFilter(xe, errorCollector); break;
case "Reform": action._reform = errorCollector.XEleGetBool(xe, xeAction); break;
case "SaveResults": action._saveResult = errorCollector.XEleGetBool(xe, xeAction); break;
case "BlendParameters": action._blendParameters = errorCollector.XEleGetBool(xe, xeAction); break;
case "Parameters": action.parameters = ReadElementGroup(xe, ReadParameter, errorCollector); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeAction); break;
}
}
return(action);
}
private static Template.Page.Table.SDCDefinition ReadTableSDCDefinition(ErrorCollector errorCollector, XElement xe)
{
Template.Page.Table.SDCDefinition sdcDefinition = new Template.Page.Table.SDCDefinition();
foreach (XElement xeSdc in xe.Elements())
{
if (xeSdc.Value == null)
{
continue;
}
switch (GetXEleName(xeSdc))
{
case "MinObsAlternative": sdcDefinition.minObsAlternativeName = xeSdc.Value; break;
case "CountNonZeroObsOnly": sdcDefinition.countNonZeroObsOnly = errorCollector.XEleGetBool(xeSdc, xe); break;
case "IgnoreActionFilter": sdcDefinition.ignoreActionFilter = errorCollector.XEleGetBool(xeSdc, xe); break;
case "Suspend": sdcDefinition.suspendSdc = errorCollector.XEleGetBool(xeSdc, xe); break;
case "SecondaryGroups": sdcDefinition.secondaryGroups = ReadSecondarySdcGroups(xeSdc, errorCollector); break;
case "SuspendSecondaryGroups": sdcDefinition.suspendSecondaryGroups = errorCollector.XEleGetBool(xeSdc, xe); break;
default: errorCollector.AddXmlUnkownEleError(xeSdc, xe); break;
}
}
return(sdcDefinition);
}
private static List <string> ReadSecondarySdcGroups(XElement xeSecGroup, ErrorCollector errorCollector)
{
List <string> secGroups = new List <string>();
foreach (XElement xe in xeSecGroup.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "NamedSecondaryGroup": if (!secGroups.Contains(xe.Value.ToLower().Trim()))
{
secGroups.Add(xe.Value.ToLower().Trim());
}
break;
case "AutoGroup": secGroups.Add(Guid.NewGuid().ToString()); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeSecGroup); break;
}
}
return(secGroups);
}
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 Template.Page.Table.Column ReadColumn(XElement xeCol, ErrorCollector errorCollector)
{
Template.Page.Table.Column col = new Template.Page.Table.Column();
foreach (XElement xe in xeCol.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": col.name = xe.Value; break;
case "IsVisible": col.isVisible = errorCollector.XEleGetBool(xe, xeCol, col.name); break;
case "HasSeparatorBefore": col.hasSeparatorBefore = errorCollector.XEleGetBool(xe, xeCol, col.name); break;
case "HasSeparatorAfter": col.hasSeparatorAfter = errorCollector.XEleGetBool(xe, xeCol, col.name); break;
case "TiesWith": col.tiesWith = errorCollector.XEleGetDouble(xe, xeCol, col.name); break;
case var ctf when commonTableFields.Contains(ctf): ReadCommonTableField(xe, col, errorCollector, xeCol, col.name); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeCol, col.name); break;
}
}
return(col);
}
private static Template.Page.Table.Row ReadRow(XElement xeRow, ErrorCollector errorCollector)
{
Template.Page.Table.Row row = new Template.Page.Table.Row();
foreach (XElement xe in xeRow.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": row.name = xe.Value; break;
case "IsVisible": row.isVisible = errorCollector.XEleGetBool(xe, xeRow, row.name); break;
case "HasSeparatorBefore": row.hasSeparatorBefore = errorCollector.XEleGetBool(xe, xeRow, row.name); break;
case "HasSeparatorAfter": row.hasSeparatorAfter = errorCollector.XEleGetBool(xe, xeRow, row.name); break;
case "ForEachDataRow": row.forEachDataRow = errorCollector.XEleGetBool(xe, xeRow, row.name); break;
case "ForEachValueOf": row.forEachValueOf = xe.Value; break;
case var ctf when commonTableFields.Contains(ctf): ReadCommonTableField(xe, row, errorCollector, xeRow, row.name); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeRow, row.name); break;
}
}
return(row);
}
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.Page ReadPage(XElement xePage, ErrorCollector errorCollector)
{
Template.Page page = new Template.Page();
foreach (XElement xe in xePage.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": page.name = xe.Value; break;
case "Title": page.title = xe.Value; break;
case "Subtitle": page.subtitle = xe.Value; break;
case "Description": page.description = xe.Value; break;
case "Button": page.button = xe.Value; break;
case "Visible": page.visible = errorCollector.XEleGetBool(xe, xePage, page.name); break;
case "PerReform": page.perReform = errorCollector.XEleGetBool(xe, xePage, page.name); break;
case "Actions": page.actions = ReadElementGroup(xe, ReadAction, errorCollector); break;
case "Tables": page.tables = ReadElementGroup(xe, ReadTable, errorCollector); break;
default: errorCollector.AddXmlUnkownEleError(xe, xePage, page.name); break;
}
}
return(page);
}
private static Template.TemplateInfo ReadInfo(XElement xeInfo, ErrorCollector errorCollector)
{
Template.TemplateInfo info = new Template.TemplateInfo();
if (xeInfo.Element("DebugMode") != null && errorCollector.XEleGetBool(xeInfo.Element("DebugMode"), xeInfo))
{
errorCollector.SetDebugMode();
}
foreach (XElement xe in xeInfo.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": info.name = xe.Value; break;
case "Title": info.title = xe.Value; break;
case "Subtitle": info.subtitle = xe.Value; break;
case "Button": info.button = xe.Value; break;
case "Description": info.description = xe.Value; break;
case "GeneralDescription": info.generalDescription = xe.Value; break;
case "MinFiles": info.minFiles = errorCollector.XEleGetInt(xe, xeInfo); break;
case "MaxFiles": info.maxFiles = errorCollector.XEleGetInt(xe, xeInfo); break;
case "HideMainSelectorForSingleFilePackage": info.HideMainSelectorForSingleFilePackage = errorCollector.XEleGetBool(xe, xeInfo); break;
case "TemplateType": info.templateType = errorCollector.XEleGetEnum <HardDefinitions.TemplateType>(xe, xeInfo); break;
case "AdditionalCalculationLevels": info.calculationLevels = ReadElementGroup(xe, ReadCalculationLevel, errorCollector); break;
case "RequiredVariables": info.requiredVariables = ReadElementGroup(xe, ReadRequiredVariable, errorCollector); break;
case "OptionalVariables": info.optionalVariables = ReadElementGroup(xe, ReadOptionalVariable, errorCollector); break;
case "UserVariables": info.userVariables = ReadElementGroup(xe, ReadUserVariable, errorCollector); break;
case "SDCDefinition": ReadTemplateInfoSDCDefinition(errorCollector, info, xe); break;
case "ExportDescriptionMode": info.exportDescriptionMode = errorCollector.XEleGetEnum <HardDefinitions.ExportDescriptionMode>(xe, xeInfo); break;
case "DebugMode": break;
default: errorCollector.AddXmlUnkownEleError(xe, xeInfo); break;
}
}
;
return(info);
}
private static Template.Page.Table ReadTable(XElement xeTable, ErrorCollector errorCollector)
{
Template.Page.Table table = new Template.Page.Table();
foreach (XElement xe in xeTable.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": table.name = xe.Value; break;
case "Title": table.title = xe.Value; break;
case "Subtitle": table.subtitle = xe.Value; break;
case "Description": table.description = xe.Value; break;
case "StringFormat": table.stringFormat = xe.Value; break;
case "ColumnGrouping": table.columnGrouping = errorCollector.XEleGetEnum <HardDefinitions.ColumnGrouping>(xe, xeTable, table.name); break;
case "Visible": table.visible = errorCollector.XEleGetBool(xe, xeTable, table.name); break;
case "Action": table.action = ReadAction(xe, errorCollector); break;
case "Graph": table.graph = ReadGraph(xe, errorCollector); break;
case "Rows": table.rows = ReadElementGroup(xe, ReadRow, errorCollector); break;
case "Columns": table.columns = ReadElementGroup(xe, ReadColumn, errorCollector); break;
case "ReformColumns": table.reformColumns = ReadElementGroup(xe, ReadColumn, errorCollector); break;
case "Cells": table.cells = ReadElementGroup(xe, ReadCell, errorCollector); break;
case "ReformCells": table.reformCells = ReadElementGroup(xe, ReadCell, errorCollector); break;
case "SDCDefinition": table.sdcDefinition = ReadTableSDCDefinition(errorCollector, xe); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeTable, table.name); break;
}
}
return(table);
}
private static List <T> GetElementGroupList <T>(IEnumerable <XElement> xes, string nameChildXE, Func <XElement, ErrorCollector, T> readFunc,
ErrorCollector errorCollector)
{
List <T> list = new List <T>(); // e.g. List<Template.Action>
foreach (XElement xe in xes)
{
if (xe.Name != nameChildXE) // all child-elements of e.g. <Actions> need to be <Action>-elements
{
errorCollector.AddXmlUnkownEleError(xe, new XElement(nameChildXE + "s"));
}
else
{
T ele = readFunc(xe, errorCollector); // call e.g. ReadAction ...
list.Add(ele); // ... and add the result to the List<Template.Action>
}
}
return(list);
}
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 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.ComboItem ReadComboItem(XElement xeCI, ErrorCollector errorCollector)
{
Template.TemplateInfo.ComboItem ci = new Template.TemplateInfo.ComboItem();
foreach (XElement xe in xeCI.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "Name": ci.name = xe.Value; break;
case "Value": ci.value = xe.Value; break;
default: errorCollector.AddXmlUnkownEleError(xe, xeCI, ci.name); break;
}
}
;
return(ci);
}
private static Template.Page.Table.Cell ReadCell(XElement xeCell, ErrorCollector errorCollector)
{
Template.Page.Table.Cell cell = new Template.Page.Table.Cell();
foreach (XElement xe in xeCell.Elements())
{
if (xe.Value == null)
{
continue;
}
switch (GetXEleName(xe))
{
case "ColNum": cell.colNum = errorCollector.XEleGetInt(xe, xeCell); break;
case "RowNum": cell.rowNum = errorCollector.XEleGetInt(xe, xeCell); break;
case var ctf when commonTableFields.Contains(ctf): ReadCommonTableField(xe, cell, errorCollector, xeCell); break;
default: errorCollector.AddXmlUnkownEleError(xe, xeCell); break;
}
}
return(cell);
}
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 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 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 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); }
}