internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Share, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.FORMULA,
minCount = 1, maxCount = 1
});
fun.par.Add(Share_Between, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.CONDITION,
minCount = 0, maxCount = 1
});
fun.par.Add(Share_All_IfNoElig, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = true
});
fun.par.Add(Share_Prop, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.VARorIL,
minCount = 0, maxCount = 1
});
fun.par.Add(Share_Equ_IfZero, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = false
});
fun.par.Add(Ignore_Neg_Prop, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = false
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Programme, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 1, maxCount = 1
});
fun.par.Add(Path, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 0, maxCount = 1
});
fun.par.Add(Argument, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 0, maxCount = DefinitionAdmin.MANY
});
fun.par.Add(UnifySlash, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = true
});
fun.par.Add(Wait, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = false
});
fun.par.Add(RepByEMPath, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 0, maxCount = 1
});
}
private static void PrintParAsDefined(FunBase fun)
{
DefinitionAdmin.Fun funDef = DefinitionAdmin.GetFunDefinition(fun.description.GetFunName());
PrintSubHeading("Possible parameters");
CompOpt(funDef.GetParList());
foreach (DefinitionAdmin.ParGroup group in funDef.GetGroupParList())
{
RandColor.WriteLine($"{(group.minCount > 0 ? "Compuslory" : "Optional")} group {group.groupName}:", colorHeading);
CompOpt(group.par, " ");
}
void CompOpt(Dictionary <string, DefinitionAdmin.Par> parList, string space = "")
{
RandColor.Write($"{space}Compulsory: ", colorHeading);
foreach (var par in parList)
{
if (par.Value.minCount > 0)
{
RandColor.Write($"{par.Key} ", GetSwapColor());
}
}
RandColor.Write(Environment.NewLine + $"{space}Optional: ", colorHeading);
foreach (var par in parList)
{
if (par.Value.minCount == 0)
{
RandColor.Write($"{par.Key} ", GetSwapColor());
}
}
Console.WriteLine();
}
}
Dictionary <string, string> GetFootnoteParametersForIntelli(int count = 3)
{
Dictionary <string, string> footnoteParameters = new Dictionary <string, string>();
DefinitionAdmin.Fun dummyFun = new DefinitionAdmin.Fun();
DefPar.Footnote.Add(dummyFun); DefQuery.AddAllPar(dummyFun);
foreach (string footnoteParameterName in dummyFun.GetParList().Keys)
{
string description = "";
for (int i = 1; i <= count; ++i) //offer 3 (resp. 'count') of each type, e.g. Amount#1, Amount#2, Amount#3
{
string name = footnoteParameterName;
if (footnoteParameterName.ToLower() == DefPar.Footnote.Amount.ToLower())
{
name = DefPar.Value.AMOUNT + DefQuery.HAS_PAR_MARKER + i.ToString(); //#_Amount -> Amount#xi
}
else
{
name = name.Replace("#_", DefQuery.HAS_PAR_MARKER + i.ToString() + "[_"); //e.g. #_LowLim -> #xi[_LowLim]
name += "]";
}
footnoteParameters.Add(name, "(new) " + description); //"(new)" in contrast to "(value)" of an existing footnote-parameter
}
}
return(footnoteParameters);
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Seed, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.NUMBER,
minCount = 0, maxCount = 1, defaultValue = 1
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Val, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.FORMULA,
minCount = 0, maxCount = DefinitionAdmin.MANY
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(file, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 1, maxCount = 1
});
fun.par.Add(path, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 1, maxCount = 1
});
fun.par.Add(RowMergeVar, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.VAR,
minCount = 1, maxCount = 1
});
fun.par.Add(ColMergeVar, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.VAR,
minCount = 0, maxCount = 1
});
fun.par.Add(InputVar, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.VAR,
minCount = 0, maxCount = 1
});
fun.par.Add(DefaultIfNoMatch, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.NUMBER,
minCount = 0, maxCount = 1, defaultValue = double.NaN
});
fun.par.Add(IgnoreNRows, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.NUMBER,
minCount = 0, maxCount = 1, defaultValue = 0.0
});
fun.par.Add(IgnoreNCols, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.NUMBER,
minCount = 0, maxCount = 1, defaultValue = 0.0
});
fun.par.Add(DoRanges, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = false
});
fun.par.Add(RepByEMPath, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 0, maxCount = 1
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Insert_Func, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT, minCount = 1, maxCount = 1
});
fun.par.Add(PAR_TYPE.PLACEHOLDER.ToString(), new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT, placeholderType = PAR_TYPE.TEXT,
minCount = 1, maxCount = DefinitionAdmin.MANY,
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(FactorVariables, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.NUMBER,
minCount = 0, maxCount = 1
});
fun.par.Add(FactorParameter, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.NUMBER,
minCount = 0, maxCount = 1
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Val, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.FORMULA,
minCount = 0, maxCount = DefinitionAdmin.MANY
});
fun.par.Add(Positive_Only, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = false
});
}
private static List <AddParameterTag> GetFullParList(string funName)
{
List <AddParameterTag> pars = new List <AddParameterTag>();
DefinitionAdmin.Fun fun = DefinitionAdmin.GetFunDefinition(funName, false); if (fun == null)
{
return(pars);
}
List <AddParameterTag> commonPars = new List <AddParameterTag>(), footnotePars = new List <AddParameterTag>();
foreach (var p in fun.GetParList())
{
AddPar(p);
}
foreach (var pg in fun.GetGroupParList())
{
foreach (var p in pg.par)
{
AddPar(p, pg);
}
}
pars.AddRange(commonPars); pars.AddRange(footnotePars); // to get parameters in order: fun/common/footnotes
return(pars);
void AddPar(KeyValuePair <string, DefinitionAdmin.Par> p, DefinitionAdmin.ParGroup pg = null)
{
if (p.Key.ToLower() == DefPar.DefConst.Const_Monetary.ToLower())
{
return; // Const_Monetary is not allowed, but needs to exist in library, because it is used in some countries (e.g. el, ie)
}
string parName = p.Key.ToUpper() == DefPar.PAR_TYPE.PLACEHOLDER.ToString().ToUpper() ? DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.PLACEHOLDER) : p.Key;
AddParameterTag apt = new AddParameterTag()
{
_parName = parName, _parDef = p.Value, _parGroup = pg
};
if (p.Value.isFootnote)
{
footnotePars.Add(apt);
}
else if (p.Value.isCommon)
{
commonPars.Add(apt);
}
else
{
pars.Add(apt);
}
}
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Dataset, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 1, maxCount = DefinitionAdmin.MANY
});
fun.par.Add(PAR_TYPE.PLACEHOLDER.ToString(), new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.FORMULA,
placeholderType = PAR_TYPE.VAR,
minCount = 0, maxCount = DefinitionAdmin.MANY
});
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(Description, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT, minCount = 1, maxCount = 1
});
fun.par.Add(Sys, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT, minCount = 1, maxCount = DefinitionAdmin.MANY
});
fun.par.Add(SysNA, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT, minCount = 0, maxCount = DefinitionAdmin.MANY
});
}
/// <summary> general parameter registration with the help of the parameter definition in Common-library </summary>
internal void TakePar(Description _description, Dictionary <string, ExeXml.Par> xmlParList)
{
description = _description;
// get the parameter definition of the function from the Common-library
DefinitionAdmin.Fun funDef = DefinitionAdmin.GetFunDefinition(description.GetFunName());
// first, try to identify parameters and, if valid, generate the respective ParXXX and put into respective list
ClassifyParameters(xmlParList, funDef);
if (description.GetFunName().ToLower() == DefFun.Scale.ToLower())
{
(this as FunScale).SetParScaleFactor();
}
// then, check for compulsory parameters
CheckForCompleteness(xmlParList, funDef);
}
internal static void Add(DefinitionAdmin.Fun fun)
{
fun.par.Add(ProduceOutput, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = true
});
fun.par.Add(OutputFileName, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.TEXT,
minCount = 0, maxCount = 1
});
fun.par.Add(ProduceTUinfo, new DefinitionAdmin.Par()
{
valueType = PAR_TYPE.BOOLEAN,
minCount = 0, maxCount = 1, defaultValue = false
});
}
private int GetMaxGroupUsedByFunction(CountryConfig.FunctionRow functionRow, string groupName)
{
int maxGroup = 0; List <string> potentialGroupPars = new List <string>();
DefinitionAdmin.Fun fun = DefinitionAdmin.GetFunDefinition(functionRow.Name, false);
if (fun != null) // find all parameters belonging to this group, e.g. functionRow.Name=BenCalc, groupName=Comp_X:
{ // find: Comp_PerTU, Comp_PerElig, Comp_Cond, Comp_LowLim, Comp_UpLim
var pgs = from pg in fun.GetGroupParList() where pg.groupName.ToLower() == groupName.ToLower() select pg;
if (pgs.Count() > 0) // this should always be fulfilled (i.e. the function has such a group)
{
foreach (var p in pgs.First().par)
{
potentialGroupPars.Add(p.Key.ToLower());
foreach (string s in p.Value.substitutes)
{
potentialGroupPars.Add(s);
}
}
}
}
foreach (CountryConfig.ParameterRow countryConfigParameterRow in functionRow.GetParameterRows())
{
if (countryConfigParameterRow.Group == string.Empty || !EM_Helpers.IsNonNegInteger(countryConfigParameterRow.Group))
{
continue; //no group parameter
}
if (!potentialGroupPars.Contains(countryConfigParameterRow.Name.ToLower()) && !IsPlaceholderSibling(countryConfigParameterRow, potentialGroupPars))
{
continue; //no sibling
}
if (EM_Helpers.SaveConvertToInt(countryConfigParameterRow.Group) > maxGroup)
{
maxGroup = EM_Helpers.SaveConvertToInt(countryConfigParameterRow.Group);
}
}
return(maxGroup);
}
internal override void PerformAction()
{
TreeListNode policyNode = _senderNode;
if (_senderNode.ParentNode != null)
{
policyNode = _senderNode.ParentNode;
}
int newFunctionNodeIndex = -1;
List <CountryConfig.FunctionRow> newFunctionRows = new List <CountryConfig.FunctionRow>();
foreach (CountryConfig.PolicyRow policyRow in (policyNode.Tag as PolicyTreeListTag).GetPolicyRows()) //loop over systems
{
CountryConfig.FunctionRow newFunctionRow = null;
//(1) add function
//if the sender node is a policy node: insert as last function ('Add Function' was called from policy node or 'Add Function After' was called from last function node in policy)
if (_senderNode == policyNode)
{
newFunctionRow = CountryConfigFacade.AddFunctionRowAtTail(_functionName, policyRow,
// the switch of a function inside an extension-policy cannot be changed, therefore add as on (otherwise one would need to remove the policy from the extension to be able to change the switch to on)
ExtensionAndGroupManager.ShowExtensionSwitchEditor(policyRow) ? DefPar.Value.ON : DefPar.Value.NA);
}
//if the sender node is a function node: insert before ('Add Function Before' was called from function node)
else
{
CountryConfig.FunctionRow neighbourFunction = (_senderNode.Tag as FunctionTreeListTag).GetFunctionRowOfSystem(policyRow.SystemRow.ID);
newFunctionRow = CountryConfigFacade.AddFunctionRow(_functionName, neighbourFunction, true,
ExtensionAndGroupManager.ShowExtensionSwitchEditor(policyRow) ? DefPar.Value.ON : DefPar.Value.NA); // see comment above
newFunctionNodeIndex = _mainForm.treeList.GetNodeIndex(_senderNode);
}
_addedFunctionsIDs.Add(newFunctionRow.ID);
//(2) add compulsory parameters
DefinitionAdmin.Fun fun = DefinitionAdmin.GetFunDefinition(_functionName, false);
if (fun != null)
{
for (short doCommon = 0; doCommon < 2; ++doCommon) // add function-specific parameters before common
{
foreach (var p in fun.GetParList())
{
AddPar(p, false);
}
foreach (var pg in fun.GetGroupParList())
{
if (pg.minCount > 0)
{
foreach (var p in pg.par)
{
AddPar(p, true);
}
}
}
void AddPar(KeyValuePair <string, DefinitionAdmin.Par> p, bool group)
{
string parName = p.Key.ToUpper() == DefPar.PAR_TYPE.PLACEHOLDER.ToString().ToUpper() ? DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.PLACEHOLDER) : p.Key;
DefinitionAdmin.Par parDef = p.Value;
if (parDef.minCount > 0 && ((doCommon == 0 && !parDef.isCommon) || (doCommon == 1 && parDef.isCommon)))
{
CountryConfigFacade.AddParameterRowAtTail(newFunctionRow, parName, parDef, group ? "1" : string.Empty);
}
}
}
}
newFunctionRows.Add(newFunctionRow);
}
_mainForm.GetTreeListBuilder().InsertFunctionNode(newFunctionRows, policyNode, newFunctionNodeIndex);
}
/// <summary>
/// try to identify parameters and, if valid, generate the respective ParXXX and put into respective lists (see above)
/// </summary>
private void ClassifyParameters(Dictionary <string, ExeXml.Par> xmlParList, DefinitionAdmin.Fun funDef)
{
int dummyGroupNumber = -9999; // this is for placeholder-parameters, see below
foreach (var xmlPar in xmlParList)
{
Description parDescription = new Description(description, xmlPar.Value, xmlPar.Key);
string xmlParName = xmlPar.Value.Name;
// first check if it is an 'ordinary' parameter ...
DefinitionAdmin.Par parDef = funDef.GetParDef(xmlParName);
if (parDef != null)
{
string officialParName = funDef.GetOfficalParName(xmlParName); // is (in contrast to xmlParName) case-sensitive and
// corresponds to constants as defined in Common-library
// generate parameter ...
ParBase par = GeneratePar(xmlPar, parDef, parDescription);
// ... and put it into the list it belongs too ...
if (parDef.isFootnote) // ... footnote-list
{
if (GetGroupNumber(xmlPar.Value, parDescription, out int dummy))
{
if (!footnotePar.ContainsKey(xmlPar.Value.Group))
{
footnotePar.Add(xmlPar.Value.Group, new Dictionary <string, ParBase>());
}
if (!footnotePar[xmlPar.Value.Group].ContainsKey(officialParName))
{
footnotePar[xmlPar.Value.Group].Add(officialParName, par);
}
else
{
ReportDoubleDef(parDescription);
}
}
}
else if (parDef.maxCount == 1) // ... unique-parameter-list
{
if (!uniquePar.ContainsKey(officialParName))
{
uniquePar.Add(officialParName, par);
if (infoStore.runConfig.warnAboutUselessGroups && !string.IsNullOrEmpty(xmlPar.Value.Group))
{
ReportUselessGroup(parDescription);
}
}
else
{
ReportDoubleDef(parDescription);
}
}
else // ... non-unique-parameter-list
{
if (!nonUniquePar.ContainsKey(officialParName))
{
nonUniquePar.Add(officialParName, new List <ParBase>());
}
nonUniquePar[officialParName].Add(par);
if (infoStore.runConfig.warnAboutUselessGroups && !string.IsNullOrEmpty(xmlPar.Value.Group))
{
ReportUselessGroup(parDescription);
}
}
continue;
}
// ... if not successuful, check if it is a group parameter ...
parDef = funDef.GetGroupParDef(xmlParName, out string groupName);
if (parDef != null)
{
if (GetGroupNumber(xmlPar.Value, parDescription, out int groupNo))
{
// generate parameter ...
ParBase par = GeneratePar(xmlPar, parDef, parDescription);
// ... and put it into group-parameter-list
if (!groupPar.ContainsKey(groupName))
{
groupPar.Add(groupName, new SortedList <int, List <ParBase> >());
}
if (!groupPar[groupName].ContainsKey(groupNo))
{
groupPar[groupName].Add(groupNo, new List <ParBase>());
}
if (parDef.maxCount > 1 || GetUniqueGroupPar <ParBase>(xmlPar.Value.Name, groupPar[groupName][groupNo]) == null)
{
groupPar[groupName][groupNo].Add(par);
}
else
{
ReportDoubleDef(parDescription);
}
}
continue;
}
// ... if still not successful, it could still be placehoder parameter ...
if (funDef.AllowsForPlaceholders())
{
parDef = funDef.GetPlaceholderDef(out string phGroupName);
ParBase par = GeneratePar(xmlPar, parDef, parDescription, true);
if (phGroupName == null) // non-group placeholder, as e.g. in SetDefault, DefIL
{
if (!placeholderPar.TryAdd(xmlParName, par))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $" {parDescription.Get()}: {xmlParName} double definition (is ignored)"
});
}
}
else // group placeholder, as e.g. in DefVar (PH, IsGlobal, IsMonetary), Uprate (PH, FactorCond)
{
GetGroupNumber(xmlPar.Value, parDescription, // note that this returns a dummy-group if the user didn't indicate one
out int groupNo, true); // as placeholders only actually need a group if they are "further specified" (e.g. uprating-factors: factor_condition)
if (!groupPar.ContainsKey(phGroupName))
{
groupPar.Add(phGroupName, new SortedList <int, List <ParBase> >());
}
if (!groupPar[phGroupName].ContainsKey(groupNo))
{
groupPar[phGroupName].Add(groupNo, new List <ParBase>());
}
groupPar[phGroupName][groupNo].Add(par);
}
continue;
}
// ... now we give up
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $" {parDescription.Get()}: unknown parameter"
});
}
if (infoStore.runConfig.warnAboutUselessGroups)
{
foreach (var groupType in groupPar)
{
if (groupType.Key.ToLower() == DefPar.SchedCalc.Band_XXX.ToLower())
{
continue;
}
foreach (var group in groupType.Value)
{
if (group.Key >= 0 && group.Value.Count == 1)
{
ReportUselessGroup(group.Value[0].description);
}
}
}
}
// internal function for generating parameters
ParBase GeneratePar(KeyValuePair <string, ExeXml.Par> xmlPar, DefinitionAdmin.Par parDef,
Description parDescription, bool isPlaceholder = false)
{
ParBase par;
switch (parDef.valueType)
{
case DefPar.PAR_TYPE.FORMULA: par = new ParFormula(infoStore); break;
case DefPar.PAR_TYPE.CONDITION: par = new ParCond(infoStore); break;
case DefPar.PAR_TYPE.BOOLEAN: par = new ParBool(infoStore); break;
case DefPar.PAR_TYPE.NUMBER: par = new ParNumber(infoStore); break;
case DefPar.PAR_TYPE.TEXT: par = new ParBase(infoStore); break;
case DefPar.PAR_TYPE.VAR: par = new ParVar(infoStore); break;
case DefPar.PAR_TYPE.OUTVAR: par = new ParOutVar(infoStore); break;
case DefPar.PAR_TYPE.IL: par = new ParIL(infoStore); break;
case DefPar.PAR_TYPE.TU: par = new ParTU(infoStore); break;
case DefPar.PAR_TYPE.VARorIL: par = new ParVarIL(infoStore); break;
case DefPar.PAR_TYPE.CATEG: par = new ParCateg(infoStore, parDef.categValues); break;
case DefPar.PAR_TYPE.PLACEHOLDER: par = new ParBase(infoStore); break;
default: throw new Exception($"Not yet properly implemented parameter value type {parDef.valueType}");
}
par.description = parDescription;
par.xmlValue = xmlPar.Value.val;
par.description.isPlaceholder = isPlaceholder;
return(par);
}
bool GetGroupNumber(ExeXml.Par p, Description parDescription, out int groupNumber, bool allowDummy = false)
{
groupNumber = dummyGroupNumber++; // placeholders (e.g.uprating factors) only actually need a group
if (string.IsNullOrEmpty(p.Group)) // if they are "further specified" (e.g.factor_condition)
{
if (allowDummy)
{
return(true);
}
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {parDescription.Get()}: missing group"
});
return(false);
}
if (int.TryParse(p.Group, out groupNumber))
{
return(true);
}
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {parDescription.Get()}: invalid group {p.Group} (must be an integer number)"
});
return(false);
}
void ReportDoubleDef(Description parDescription)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {parDescription.Get()}: defined more than once"
});
}
void ReportUselessGroup(Description parDescription)
{
if (parDescription.GetFunName() != DefFun.Store) // add a special exception for Store, as it has its own reporting
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $" {parDescription.Get()}: group has no use"
});
}
}
}
/// <summary> check for compulsory parameters </summary>
private void CheckForCompleteness(Dictionary <string, ExeXml.Par> xmlParList, DefinitionAdmin.Fun funDef)
{
// check if compulsory non-group parameters are available
foreach (var p in funDef.GetParList())
{
string parName = p.Key; DefinitionAdmin.Par parDef = p.Value;
if (parDef.minCount == 0)
{
continue; // optional parameter (e.g. Allocate's Share_Between)
}
// (note that footnote-parameters are always optional)
bool found = false;
if (parDef.maxCount == 1) // check for unique compulsory parameter (e.g. ArithOp's Formula)
{
if (GetUniquePar <ParBase>(parName) != null)
{
found = true;
}
else // could still be available as substitute (e.g. output_var not available, but output_add_var)
{
foreach (string substitute in parDef.substitutes)
{
if (GetUniquePar <ParBase>(substitute) != null)
{
found = true; break;
}
}
;
}
}
if (parDef.maxCount > 1) // check for non-unique parameter, where at least one must be defined (e.g. SetDefault's Dataset)
{
if (GetNonUniquePar <ParBase>(parName).Count > 0)
{
found = true;
}
else // unlikely, but could still be available as substitute
{
foreach (string substitute in parDef.substitutes)
{
if (GetNonUniquePar <ParBase>(substitute).Count > 0)
{
found = true; break;
}
}
;
}
}
if (!found)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {description.Get()}: compulsory parameter {parName} is missing"
});
}
}
// check if compulsory groups, and compulsory parameter within groups are available
foreach (var groupDef in funDef.GetGroupParList())
{
if (groupDef.minCount > 0) // check for compulsory group, e.g. BenCalc's Comp_X-group
{
if (!groupPar.ContainsKey(groupDef.groupName))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {description.Get()}: compulsory group {groupDef.groupName} is missing"
});
}
}
// whether or not the group is compulsory it can (if existent) ask for completeness, i.e. have compulsory parts
if (!groupPar.ContainsKey(groupDef.groupName))
{
continue; // no such group exists
}
foreach (var p in groupDef.par) // loop over the group-definition's parameters (e.g. Comp_Cond, Comp_perTU, Comp_LowLim, ...)
{
string parName = p.Key; DefinitionAdmin.Par parDef = p.Value;
if (parDef.minCount == 0)
{
continue; // optional parameter (e.g. Comp_LowLim)
}
// check for compulsory parameter (e.g. Comp_Cond)
foreach (var g in GetParGroups(groupDef.groupName)) // loop over all existent groups
{ // (e.g. all components of an actual BenCalc)
int groupNo = g.Key; List <ParBase> groupPar = g.Value;
int found = 0;
if (parDef.maxCount == 1) // check for unique compulsory group-parameter (e.g. BenCalc's Comp_Cond)
{
if (GetUniqueGroupPar <ParBase>(parName, groupPar) != null)
{
++found;
}
foreach (string substitute in parDef.substitutes)
{
if (GetUniqueGroupPar <ParBase>(substitute.ToLower(), groupPar) != null)
{
++found;
}
}
if (found > 1)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {description.Get()}: double definition of group-parameter {parName} (group {groupNo})"
});
}
}
if (parDef.maxCount > 1) // check for non-unique compulsory group-parameter (e.g. Uprate's AggVarPart)
{
if (GetNonUniqueGroupPar <ParBase>(parName, groupPar).Count > 0)
{
++found;
}
foreach (string substitute in parDef.substitutes)
{
if (GetNonUniqueGroupPar <ParBase>(substitute.ToLower(), groupPar).Count > 0)
{
++found;
}
}
}
if (found == 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $" {description.Get()}: compulsory group-parameter {parName} (group {groupNo}) is missing"
});
}
}
}
}
}
//returns the footnote parameters which need to be added when a formula was changed
//e.g. formula contains 'Amount#4711' (and did not contain that before the change): footnote parameter #Amount with group 4711 must be added
internal static Dictionary <KeyValuePair <string, string>, DefinitionAdmin.Par> GetFootnoteParametersToAdd(TreeListNode node, ref string formulaText)
{
Dictionary <KeyValuePair <string, string>, DefinitionAdmin.Par> footnoteParametersToAdd =
new Dictionary <KeyValuePair <string, string>, //name and group of new footnote parameter
DefinitionAdmin.Par>(); //definition (from config file) of new parameter
int nextFootnote = TreeListManager.GetNextAvailableFootnoteCounter(node.ParentNode);
string functionName = node.ParentNode.GetDisplayText(TreeListBuilder._policyColumnName);
//search for Amount#xi (i.e Amount#x1, Amount#x2, etc.)
for (int indexLabelAmount = formulaText.ToLower().IndexOf(DefPar.Value.AMOUNT.ToLower() + "#x"), indexNonDigit;
indexLabelAmount >= 0;
indexLabelAmount = formulaText.ToLower().IndexOf(DefPar.Value.AMOUNT.ToLower() + "#x"))
{
for (indexNonDigit = indexLabelAmount + DefPar.Value.AMOUNT.Length + 2;
indexNonDigit < formulaText.Length && EM_Helpers.IsDigit(formulaText.ElementAt(indexNonDigit));
++indexNonDigit)
{
; //search first non digit after Amount#x
}
string parameterName = "#_" + DefPar.Value.AMOUNT; //#_Amount
DefinitionAdmin.Par parDef = DefinitionAdmin.GetParDefinition(functionName, parameterName);
KeyValuePair <string, string> parameterNameAndGroup = new KeyValuePair <string, string>(parameterName, nextFootnote.ToString());
footnoteParametersToAdd.Add(parameterNameAndGroup, parDef); //put parameter into list of footnote parameters which need to be generated
string toReplace = SubstringFromTo(formulaText, indexLabelAmount, indexNonDigit - 1); //Amount#xi (e.g. Amount#x1)
string replaceBy = DefPar.Value.AMOUNT + "#" + nextFootnote.ToString(); //Amount#f (e.g. Amount#x3)
formulaText = formulaText.Replace(toReplace, replaceBy); //replace all occurrences (there might be more than one)
++nextFootnote;
}
//search for #xi[_yyy] (i.e. #x1[_Level], #x2[_Level], #x1[_UpLim], etc.)
for (int indexPlaceholder = formulaText.IndexOf("[_");
indexPlaceholder >= 0;
indexPlaceholder = formulaText.IndexOf("[_"))
{
int iStart = formulaText.Substring(0, indexPlaceholder).LastIndexOf("#x");
int iEnd = formulaText.Substring(indexPlaceholder).IndexOf("]") + indexPlaceholder;
if (iStart >= 0 && iEnd >= 0 &&
EM_Helpers.IsNonNegInteger(SubstringFromTo(formulaText, iStart + 2, indexPlaceholder - 1)))
{
string parameterName = "#" + SubstringFromTo(formulaText, indexPlaceholder + 1, iEnd - 1); //#_yyy (e.g. #_Level)
DefinitionAdmin.Fun funDef = DefinitionAdmin.GetFunDefinition(functionName, false); // check if function allows for this footnote
if (funDef != null && (from p in funDef.GetParList() where p.Value.isFootnote && p.Key.ToLower() == parameterName.ToLower() select p).Count() > 0)
{
DefinitionAdmin.Par parDef = DefinitionAdmin.GetParDefinition(functionName, parameterName);
KeyValuePair <string, string> parameterNameAndGroup = new KeyValuePair <string, string>(parameterName, nextFootnote.ToString());
footnoteParametersToAdd.Add(parameterNameAndGroup, parDef); //put parameter into list of footnote parameters which need to be generated
string toReplace = SubstringFromTo(formulaText, iStart, iEnd); //#xi_yyy (e.g. #x1[_Level])
string replaceBy = "#" + nextFootnote.ToString(); //#f_yyy (e.g. #4)
formulaText = formulaText.Replace(toReplace, replaceBy); //replace all occurrences (there might be more than one)
++nextFootnote;
}
else
{
break; //should not happen (though can), but to avoid infinite loop
}
}
else
{
break; //should not happen (though can), but to avoid infinite loop
}
}
//search for query#x (e.g. isNtoMchild#x)
for (int indexPlaceholder = formulaText.IndexOf("#x");
indexPlaceholder >= 0;
indexPlaceholder = formulaText.IndexOf("#x"))
{
string theQuery = string.Empty;
foreach (string queryName in DefinitionAdmin.GetQueryNamesAndDesc().Keys)
{
string potQueryName = SubstringFromTo(formulaText, indexPlaceholder - (queryName.Length - 2), indexPlaceholder + 1).ToLower();
if (potQueryName == queryName.ToLower())
{
theQuery = queryName;
break;
}
}
if (theQuery == string.Empty)
{
formulaText = formulaText.Substring(0, indexPlaceholder) + "#°" +
formulaText.Substring(indexPlaceholder + 2); //no query found, replace #x preliminary by #° (change back below)
}
else //add all parameters of the query
{
Dictionary <string, DefinitionAdmin.Par> queryParameters = new Dictionary <string, DefinitionAdmin.Par>();
DefinitionAdmin.GetQueryDefinition(theQuery, out DefinitionAdmin.Query queryDef, out string dummy, false);
if (queryDef != null)
{
queryParameters = queryDef.par;
}
List <string> alreadyCoveredByAlias = new List <string>(); // avoid adding e.g. #_income as well as #_info
foreach (var q in queryParameters)
{
string queryParName = q.Key; DefinitionAdmin.Par queryParDef = q.Value;
if (alreadyCoveredByAlias.Contains(queryParName))
{
continue;
}
footnoteParametersToAdd.Add(new KeyValuePair <string, string>(queryParName, nextFootnote.ToString()), queryParDef); //put parameter into list of footnote parameters which need to be generated
alreadyCoveredByAlias.AddRange(queryParDef.substitutes);
}
formulaText = formulaText.Substring(0, indexPlaceholder) + "#" + nextFootnote.ToString() +
formulaText.Substring(indexPlaceholder + 2); //replace #x by #f (e.g. #x by #5)
++nextFootnote;
}
}
formulaText = formulaText.Replace("#°", "#x");
return(footnoteParametersToAdd);
}
