protected override void PrepareNonCommonPar()
{
ParNumber parSeed = GetUniquePar <ParNumber>(DefPar.RandSeed.Seed);
seed = parSeed != null ? (int)parSeed.GetValue() :
DefinitionAdmin.GetParDefault <int>(DefFun.RandSeed, DefPar.RandSeed.Seed);
}
internal static bool ValidateEditorInput(string value, TreeListNode node, TreeListColumn column, ref string errorText)
{
if (value == DefPar.Value.NA)
{
return(true);
}
CountryConfig.ParameterRow countryParameterRow = (node.Tag as ParameterTreeListTag).GetDefaultParameterRow();
SystemTreeListTag systemColumnTag = column.Tag as SystemTreeListTag;
switch (DefinitionAdmin.GetParDefinition(countryParameterRow.FunctionRow.Name, countryParameterRow.Name).valueType)
{
case DefPar.PAR_TYPE.FORMULA: return(ValidateFormula(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.CONDITION: return(ValidateCondition(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.TEXT: return(ValidateString(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.NUMBER: return(ValidateAmount(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.VAR: return(ValidateVariable(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.VARorIL: return(ValidateVariableIncomelist(value, systemColumnTag, ref errorText));
}
return(true);
}
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();
}
}
private bool IsPlaceholderSibling(CountryConfig.ParameterRow parRow, List <string> potentialGroupPars)
{
if (!potentialGroupPars.Contains(DefPar.PAR_TYPE.PLACEHOLDER.ToString().ToLower()))
{
return(false);
}
return(DefinitionAdmin.GetParDefinition(parRow.FunctionRow.Name, parRow.Name, false) == null);
}
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);
}
}
}
RepositoryItemComboBox GetCategoriesEditor()
{
if (_categoriesEditor != null)
{
return(_categoriesEditor);
}
_categoriesEditor = new RepositoryItemComboBox();
_categoriesEditor.TextEditStyle = DevExpress.XtraEditors.Controls.TextEditStyles.DisableTextEditor;
_categoriesEditor.CloseUpKey = new DevExpress.Utils.KeyShortcut(Keys.Alt | Keys.Down);
_categoriesEditor.Items.AddRange(DefinitionAdmin.GetParDefinition(GetFunctionName(), GetParameterName()).categValues);
_categoriesEditor.Items.Add(DefPar.Value.NA);
_categoriesEditor.MouseWheel += new MouseEventHandler(_categoriesEditor_MouseWheel);
return(_categoriesEditor);
}
internal override bool IsPolicyColumnEditable()
{
if (_policyColumnEditable == PolicyColumnEditable.no_idea) //performance optimisation Aug 13: store editability instead of assessing each time
{
if (DefinitionAdmin.GetParDefinition(GetFunctionName(), GetParameterName(), false) != null)
{
_policyColumnEditable = PolicyColumnEditable.no; // a concrete parameter was found (e.g. ArithOp/Formula)
}
else
{
_policyColumnEditable = PolicyColumnEditable.yes;
}
}
return(_policyColumnEditable == PolicyColumnEditable.yes);
}
internal static EM_AppContext Create_EM_AppContext(EM_UI_MainForm countryMainForm)
{
singleton = new EM_AppContext(countryMainForm);
_emptyForm = countryMainForm;
//show the dialog where the user can set the default pathes, if the folder to the country-xml-files does not exist
if (!Directory.Exists(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles)))
{
ConfigurePathsForm configurePathsForm = new ConfigurePathsForm();
configurePathsForm.ShowDialog();
}
singleton.SetBrand(); // allow UI to show another look, i.e. present a brand alternative to EUROMOD
DefinitionAdmin.Init(); // initialise the common-lib's description of functions and parametes (once for the life-time of the lib)
return(singleton);
}
internal override List <int> GetTypeSpecificIntelliItems(SystemTreeListTag systemTag)
{
List <int> specficIntelliItems = null;
string valType = _parameterRows[systemTag.GetSystemRow().ID].ValueType.ToLower();
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.VARorIL).ToLower())
{
specficIntelliItems = new List <int>();
specficIntelliItems.Add(FormulaEditorManager._intelliContainsStandardVar);
specficIntelliItems.Add(FormulaEditorManager._intelliContainsDefVar);
specficIntelliItems.Add(FormulaEditorManager._intelliContainsDefConst);
specficIntelliItems.Add(FormulaEditorManager._intelliContainsDefIL);
specficIntelliItems.Add(FormulaEditorManager._intelliContainsUpRateFactor);
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.VAR).ToLower())
{
specficIntelliItems = new List <int>();
specficIntelliItems.Add(FormulaEditorManager._intelliContainsStandardVar);
specficIntelliItems.Add(FormulaEditorManager._intelliContainsDefVar);
specficIntelliItems.Add(FormulaEditorManager._intelliContainsDefConst);
if (GetDefaultParameterRow().Name.ToLower() != DefPar.Common.Output_Var.ToLower() &&
GetDefaultParameterRow().Name.ToLower() != DefPar.Common.Output_Add_Var.ToLower())
{
specficIntelliItems.Add(FormulaEditorManager._intelliContainsUpRateFactor);
}
}
if (IsDefTUMember())
{
specficIntelliItems = new List <int>()
{
FormulaEditorManager._intelliContainsDefTUMembers
}
}
;
if (IsUprateFactor())
{
specficIntelliItems = new List <int>()
{
FormulaEditorManager._intelliContainsUpRateFactor
}
}
;
return(specficIntelliItems);
}
/// <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);
}
private T GetParValueOrDefault <T, parT>(string funName, string parName, BNT boolNumText)
{
parT par = GetUniquePar <parT>(parName);
if (par == null)
{
return(DefinitionAdmin.GetParDefault <T>(funName, parName));
}
switch (boolNumText)
{
case BNT.BOOL: return((T)((par as ParBool).GetBoolValue() as object));
case BNT.NUM: return((T)((par as ParNumber).GetValue() as object));
case BNT.TEXT: return((T)((par as ParBase).xmlValue as object));
}
throw new Exception("GetParValueOrDefault failed");
}
internal OperandAdmin(InfoStore _infoStore)
{
infoStore = _infoStore;
// add the "static" elements to the operand-index, i.e.all queries ...
foreach (string queryName in DefinitionAdmin.GetQueryNamesAndAliases())
{
RegisterOperand(name: queryName,
description: null, // is used for error-messages only, and this should not fail
operand: new Operand(_parType: DefPar.PAR_TYPE.QUERY,
_creatorFun: string.Empty,
_isGlobal: false, // is ignored and actually set in ParQuery.CheckAndPrepare
_isMonetary: false, // not relevant for a query (i.e. is a variable-attribute)
_isWriteable: false, // ditto
_addToHHPersonList: false, // ditto
_readFromFile: false, // ditto
_isInitialised: true)); // ditto
}
// register fundamental variables, IDs, DAG, DGN, ...
foreach (string fv in new List <string>()
{
DefVarName.IDHH, DefVarName.IDPERSON,
DefVarName.IDMOTHER, DefVarName.IDFATHER, DefVarName.IDPARTNER,
DefVarName.DAG, DefVarName.DGN, DefVarName.DEC, DefVarName.DWT,
DefVarName.DMS, DefVarName.LES, DefVarName.LOC,
DefVarName.DEFAULT_ELIGVAR
})
{
bool readFromFile = fv != DefVarName.DEFAULT_ELIGVAR;
RegisterOperand(name: fv,
description: null, // see above
operand: new Operand(_parType: DefPar.PAR_TYPE.VAR,
_creatorFun: string.Empty,
_isGlobal: false,
_isMonetary: false,
_isWriteable: true, // in principle though usually useless
_addToHHPersonList: true,
_readFromFile: readFromFile,
_isInitialised: true));
}
}
// note that at this stage parameters are available (via GetxxxPar-functions of FunBase)
// but not yet prepared, i.e. only xmlValue is available
internal override void ProvideIndexInfo()
{
ParBase parName = GetUniquePar <ParBase>(DefPar.DefIl.Name); if (parName == null)
{
return;
}
Dictionary <string, double> content = new Dictionary <string, double>();
foreach (var part in GetPlaceholderPar <ParBase>())
{
string varILName = part.Key;
content.Add(varILName, GetAddMod(part.Value)); // note that vars/ILs are 'registered' (i.e.a.o. checked) in ParIL.CheckAndPrepare (i.e. on 1st use)
}
ParBool parWarn = GetUniquePar <ParBool>(DefPar.DefIl.Warn_If_NonMonetary);
bool warnIfNonMon = parWarn == null?DefinitionAdmin.GetParDefault <bool>(DefFun.DefIl, DefPar.DefIl.Warn_If_NonMonetary) :
ParBool.IsTrue(parWarn.xmlValue); // note: GetParBoolValueOrDefault cannot be used as parameter WarnIfNonMon is not yet checked
infoStore.operandAdmin.RegisterIL(parName.xmlValue, DefFun.DefIl, description, content, warnIfNonMon);
}
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);
}
private bool RunSequential(SpineAdmin spineManager)
{
int curFunIndex = 0;
Dictionary <FunBase, List <FunUnitLoop> > unitLoopRanges = spineManager.GetUnitLoopRangesForSequentialRun();
while (true) // loop over functions
{
FunBase fun = spineManager.GetNextFun(ref curFunIndex); if (fun == null)
{
break;
}
DefFun.RUN_MODE runMode = // find out if the function expects to be run within HH-loop or not
DefinitionAdmin.GetFunDefinition(fun.description.GetFunName()).runMode;
if (runMode != DefFun.RUN_MODE.IN_SPINE)
{
(fun as FunOutOfSpineBase).Run(); // concerns functions usually running pre- or post-spine (DefOutput, Totals, etc.)
}
else
{
// concerns functions usually running in spine (BenCalc, Elig, etc.)
FunInSpineBase spineFun = fun as FunInSpineBase;
if (infoStore.runConfig.forceSequentialRun)
{
// run in a single thread
foreach (HH hh in infoStore.hhAdmin.hhs)
{
foreach (List <Person> tu in hh.GetTUs(spineFun.GetTUName()))
{
SpineFunRun(spineFun, hh, tu);
}
}
}
else
{
// run in multiple threads
Parallel.ForEach <HH>(infoStore.hhAdmin.hhs, hh => {
foreach (List <Person> tu in hh.GetTUs(spineFun.GetTUName()))
{
SpineFunRun(spineFun, hh, tu);
}
});
}
}
if (!infoStore.communicator.ReportProgress(
new Communicator.ProgressInfo()
{
message = $"Done with function {fun.description.Get(true)}"
}))
{
return(false);
}
}
return(true);
void SpineFunRun(FunInSpineBase spineFun, HH hh, List <Person> tu)
{
bool run = false;
if (unitLoopRanges.ContainsKey(spineFun)) // there are UnitLoops in the spine
{ // note that a function may be enclosed by more than one UnitLoop (see NRR add-on)
foreach (FunUnitLoop ul in unitLoopRanges[spineFun]) // if any of the UnitLoops allows running - run
{
if (!ul.IsFinished(hh))
{
run = true;
}
}
}
else
{
run = true; // the usual case - no UnitLoops
}
if (run)
{
spineFun.Run(hh, tu);
}
}
}
void AddParameters()
{
//analyse all AddOn_Par functions
foreach (CountryConfig.FunctionRow function_AddOnParameters in
_addOnCountryConfigFacade.GetFunctionRowsBySystemIDAndFunctionName(_addOnSystemRow.ID, DefFun.AddOn_Par))
{
if (function_AddOnParameters.Switch.ToLower() != DefPar.Value.ON.ToLower())
{
continue;
}
//assess which parameters are to be merged and into which function by interpreting the AddOnPar-function's parameters
CountryConfig.ParameterRow parameter_InsertFunctionID = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnParameters.ID, DefPar.AddOn_Par.Insert_Func);
if (parameter_InsertFunctionID == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnParameters, "Compulsory parameter '" + DefPar.AddOn_Par.Insert_Func + "' not defined.");
continue;
}
//search for the function where parameters are to be added in the just generated (copied) system
CountryConfig.FunctionRow addOnParameters_InsertFunction = _mergeCountryConfigFacade.GetFunctionRowByID(parameter_InsertFunctionID.Value);
if (addOnParameters_InsertFunction == null) //take account of 'symbolic' identifier, e.g. output_std_sl_#3
{
addOnParameters_InsertFunction = ImportExportHelper.GetFunctionRowBySymbolicID(parameter_InsertFunctionID.Value, _mergeCountryConfigFacade, _mergeSystemRow.ID);
}
if (addOnParameters_InsertFunction == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnParameters, "Unknown function '" + parameter_InsertFunctionID.Value + "'.");
continue;
}
//if everything is ok, insert the parameters (all other parameters than insert_func in AddOn_Par) into the function
foreach (CountryConfig.ParameterRow addOnParameters_ParameterNameAndValue in function_AddOnParameters.GetParameterRows())
{
if (addOnParameters_ParameterNameAndValue.Name.ToLower() == DefPar.AddOn_Par.Insert_Func.ToLower())
{
continue;
}
DefinitionAdmin.Par parDef = DefinitionAdmin.GetParDefinition(addOnParameters_InsertFunction.Name, addOnParameters_ParameterNameAndValue.Name, false);
if (parDef == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnParameters,
"Function '" + addOnParameters_InsertFunction.Name + "' does not allow for parameter '" + addOnParameters_ParameterNameAndValue.Name + "'.");
continue;
}
//add parameter, however if a respective parameter with value n/a exists, it can be used
//this is even necessary for single parameters (which may only exist once) if an add-on is added more than once (i.e. there is already the n/a parameter of the first adding-on)
CountryConfig.ParameterRow parameterRow = null;
List <CountryConfig.ParameterRow> parameterList = (from pR in addOnParameters_InsertFunction.GetParameterRows()
where pR.Name.ToLower() == addOnParameters_ParameterNameAndValue.Name.ToLower() &&
pR.Group == addOnParameters_ParameterNameAndValue.Group &&
pR.Value == DefPar.Value.NA
select pR).ToList();
if (parameterList.Count != 0)
{
parameterRow = parameterList.First();
}
if (parameterRow == null)
{
parameterRow = CountryConfigFacade.AddParameterRowAtTail(addOnParameters_InsertFunction, addOnParameters_ParameterNameAndValue.Name, parDef);
}
if (parameterRow.Name.ToLower() == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.PLACEHOLDER).ToLower())
{
parameterRow.Name = addOnParameters_ParameterNameAndValue.Name; //for adding parameters e.g. to function DefIL
}
parameterRow.Value = addOnParameters_ParameterNameAndValue.Value;
parameterRow.Comment = addOnParameters_ParameterNameAndValue.Comment;
ImportExportHelper.ReplaceCountrySymbol(parameterRow, _mergeCountryConfigFacade.GetCountryShortName()); //replace all incidents of =cc= by country symbol
}
}
}
internal InfoStore()
{
DefinitionAdmin.Init(); // initialise the common-lib's description of functions and parametes (once for the life-time of the lib)
operandAdmin = new OperandAdmin(this);
}
internal override RepositoryItem GetEditor(TreeListNode senderNode, TreeListColumn senderColumn)
{
RepositoryItem editor = null;
SystemTreeListTag systemTag = senderColumn.Tag as SystemTreeListTag;
if (systemTag == null)
{
return(null);
}
if (!_parameterRows.ContainsKey(systemTag.GetSystemRow().ID))
{
return(null);
}
string valType = _parameterRows[systemTag.GetSystemRow().ID].ValueType.ToLower();
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.BOOLEAN).ToLower())
{
editor = _mainForm.YesNoEditorCombo;
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.FORMULA).ToLower())
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.CONDITION).ToLower())
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.CATEG).ToLower())
{
editor = GetCategoriesEditor();
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.IL).ToLower())
{
editor = systemTag.GetILEditor();
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.VAR).ToLower())
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.TU).ToLower())
{
editor = systemTag.GetTUEditor();
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.TEXT).ToLower())
{
if (IsUprateFactor() || IsDefTUMember()) // to allow for suggesting uprating-factors resp. DefTU/Members via intelliSense
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
}
if (valType == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.VARorIL).ToLower())
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
//allows free editing or add-on parameters, otherwise e.g. taxunits could not be set, as they may be defined in an other country and not in the add-on-system
if (_mainForm._isAddOn)
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
//special handling for IlArithOp/ILName: showing ils would not offer the ils generated by IlArithOp/Out_ILName
if (GetFunctionName().ToLower() == DefFun.IlArithOp.ToLower() && GetParameterName().ToLower() == DefPar.IlArithOp.ILName.ToLower())
{
editor = _mainForm.GetFormulaEditorManager().CreateEditor(senderNode, senderColumn);
}
return(editor);
}
public override void Execute(TreeListNode senderNode)
{
if (senderNode.Tag == null || (senderNode.Tag as BaseTreeListTag).GetParameterName() == null)
{
return; //policy- or function-node
}
ParameterTreeListTag nodeTag = senderNode.Tag as ParameterTreeListTag;
UsedComponent usedComponent = new UsedComponent();
foreach (CountryConfig.ParameterRow parameterRow in nodeTag.GetParameterRows())
{
if (!_systemIDs.Contains(parameterRow.FunctionRow.PolicyRow.SystemID))
{
continue;
}
if (_ignoreIfSwitchedOff && (parameterRow.FunctionRow.Switch.ToLower() == DefPar.Value.OFF ||
parameterRow.FunctionRow.PolicyRow.Switch.ToLower() == DefPar.Value.OFF))
{
continue;
}
//formulas and conditions need a special comparison operation ...
if (parameterRow.ValueType.ToLower() == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.CONDITION).ToLower() ||
parameterRow.ValueType.ToLower() == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.FORMULA).ToLower())
{
if (!_doPatternSearch)
{
if (!EM_Helpers.DoesFormulaContainComponent(parameterRow.Value, _componentName))
{
continue;
}
}
else
{
if (!EM_Helpers.DoesValueMatchPattern(_componentName, parameterRow.Value, false, true))
{
continue;
}
}
}
//... for other parameter types it's enough to compare the value
else
{
if (!_doPatternSearch)
{
if (parameterRow.Value.ToLower() != _componentName.ToLower())
{
continue;
}
}
else
{
if (!EM_Helpers.DoesValueMatchPattern(_componentName, parameterRow.Value, false, true))
{
continue;
}
}
}
usedComponent._systemNames.Add(parameterRow.FunctionRow.PolicyRow.SystemRow.Name);
}
//take account of the fact that the policy column also may contain components (i.e. variables in DefIL, SetDefault, Uprate, etc.)
if (nodeTag.IsPolicyColumnEditable())
{
string contentPolicyColumn = senderNode.GetDisplayText(senderNode.TreeList.Columns.ColumnByName(TreeListBuilder._policyColumnName));
if (EM_Helpers.DoesValueMatchPattern(_componentName, contentPolicyColumn, false, false))
{
usedComponent._row = TreeListManager.GetNodeRowNumber(senderNode, senderNode.ParentNode);
}
}
if (usedComponent._systemNames.Count == 0 && usedComponent._row == string.Empty)
{
return;
}
usedComponent._policyName = nodeTag.GetPolicyName();
usedComponent._functionName = nodeTag.GetFunctionName();
if (usedComponent._row == string.Empty)
{
usedComponent._parameterName = nodeTag.GetParameterName();
}
usedComponent._row = TreeListManager.GetNodeRowNumber(senderNode, senderNode.ParentNode);
usedComponent._node = senderNode;
_usedComponents.Add(usedComponent);
}
//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);
}
private void EM2_FixUprating(CountryConfig.SystemRow sr1, Dictionary <string, string> upratingFactors, Dictionary <string, string> upratingFactors2, string countryShortName, double alpha, int uprateType, bool treatAsMarket)
{
// first get the ils_origy & ils_ben components
CountryConfig.PolicyRow ilsdef = sr1.GetPolicyRows().FirstOrDefault(p => p.Name.ToLower() == ("ilsdef_" + countryShortName).ToLower());
if (ilsdef == null)
{
ilsdef = sr1.GetPolicyRows().FirstOrDefault(p => p.Name.ToLower() == ("ildef_" + countryShortName).ToLower());
}
if (ilsdef == null)
{
return;
}
CountryConfig.FunctionRow[] il_funcs = ilsdef.GetFunctionRows();
List <string> ils_origy = ExpandIncomeList(DefVarName.ILSORIGY, il_funcs).Keys.ToList();
List <string> ils_ben = ExpandIncomeList(DefVarName.ILSBEN, il_funcs).Keys.ToList();
List <string> overrideInclude = ExpandIncomeList("pet_override", il_funcs).Where(x => x.Value).Select(x => x.Key).ToList();
List <string> overrideExclude = ExpandIncomeList("pet_override", il_funcs).Where(x => !x.Value).Select(x => x.Key).ToList();
List <string> reservedWords = new List <string> {
"dataset", "def_factor", "factor_name", "factor_value", "factor_condition", "aggvar_name", "aggvar_part", "aggvar_tolerance", "warnifnofactor", "run_cond"
};
// Then apply them to the appropriate variables of s1
foreach (CountryConfig.FunctionRow fr in sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("Uprate_" + countryShortName).ToLower()).GetFunctionRows())
{
if (fr.Name.ToLower() == "uprate")
{
foreach (CountryConfig.ParameterRow pr in fr.GetParameterRows())
{
string pn = pr.Name.ToLower();
if (!reservedWords.Contains(pn))
{
if (uprateType == 3) // uprate all
{
double val;
if (upratingFactors.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors2[pr.Value.ToLower()]) * alpha).ToString());
}
else if (EM_Helpers.TryConvertToDouble(pr.Value.ToLower(), out val))
{
pr.Value = FixDecSep((val * alpha).ToString());
}
}
else
{
bool marketIncome = overrideInclude.Contains(pn); // if in the override include list
if (!overrideExclude.Contains(pn) && !marketIncome) // else if not in the override exlcude list
{
VarConfig.VariableRow v = EM_AppContext.Instance.GetVarConfigFacade().GetVariableByName(pn);
if (v == null || v.Monetary != "1")
{
marketIncome = false;
}
else
{
if (treatAsMarket)
{
marketIncome = !pn.EndsWith(DefGeneral.POSTFIX_SIMULATED);
}
else
{
marketIncome = !ils_ben.Contains(pn) && (pn[0] == 'y' || pn[0] == 'a' || pn[0] == 'x' || ils_origy.Contains(pn));
}
}
}
// if this is a market income
if (marketIncome)
{
if (uprateType == 1)
{
double val;
if (upratingFactors.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors[pr.Value.ToLower()]) * alpha).ToString());
}
else if (EM_Helpers.TryConvertToDouble(pr.Value.ToLower(), out val))
{
pr.Value = FixDecSep((val * alpha).ToString());
}
}
else if (uprateType == 2)
{
if (upratingFactors.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors[pr.Value.ToLower()])).ToString());
}
}
}
else // if it is non-market income
{
if (uprateType == 2)
{
double val;
if (upratingFactors2.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors2[pr.Value.ToLower()]) / alpha).ToString());
}
else if (EM_Helpers.TryConvertToDouble(pr.Value.ToLower(), out val))
{
pr.Value = FixDecSep((val / alpha).ToString());
}
}
}
}
}
}
}
}
if (uprateType > 1)
{
string[] monetaryTypes = new string[] { DefPeriod.M, DefPeriod.Y, DefPeriod.Q, DefPeriod.W,
DefPeriod.D, DefPeriod.L, DefPeriod.S, DefPeriod.C };
foreach (CountryConfig.FunctionRow fr in sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("Uprate_" + countryShortName).ToLower()).GetFunctionRows())
{
foreach (CountryConfig.ParameterRow pr in fr.GetParameterRows())
{
string val = pr.Value.ToLower().Trim();
if (val.Length < 3)
{
continue;
}
string valType = val.Substring(val.Length - 2);
if (monetaryTypes.Contains(valType))
{
val = val.Substring(0, val.Length - 2);
if (uprateType == 2)
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(val) / alpha).ToString()) + valType;
}
else if (uprateType == 3)
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(val) * alpha).ToString()) + valType;
}
}
}
}
}
try
{
// Then, fix the output filenames
sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput")
.GetParameterRows().First(p => p.Name.ToLower() == "file")
.Value = sr1.Name + "_std";
sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_hh_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput")
.GetParameterRows().First(p => p.Name.ToLower() == "file")
.Value = sr1.Name + "_std_hh";
// Finally, if required, do the scaling
if (checkRadioMarket.Checked)
{
CountryConfig.FunctionRow fr = sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput");
CountryConfig.FunctionRow fr_hh = sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_hh_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput");
if (fr.GetParameterRows().Count(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower()) == 0)
{
CountryConfig.ParameterRow fpr = fr.GetParameterRows().First(p => p.Name.ToLower() == "file");
CountryConfig.ParameterRow cpr = CountryConfigFacade.AddParameterRow(fpr, false,
DefPar.DefOutput.MultiplyMonetaryBy, DefinitionAdmin.GetParDefinition(DefFun.DefOutput, DefPar.DefOutput.MultiplyMonetaryBy));
cpr.Value = FixDecSep((1 / alpha).ToString());
}
else
{
CountryConfig.ParameterRow mpr = fr.GetParameterRows().First(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower());
double d;
if (!EM_Helpers.TryConvertToDouble(mpr.Value, out d))
{
d = 1;
}
mpr.Value = FixDecSep((d / alpha).ToString());
}
if (fr_hh.GetParameterRows().Count(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower()) == 0)
{
CountryConfig.ParameterRow fpr_hh = fr_hh.GetParameterRows().First(p => p.Name.ToLower() == "file");
CountryConfig.ParameterRow cpr = CountryConfigFacade.AddParameterRow(fpr_hh, false,
DefPar.DefOutput.MultiplyMonetaryBy, DefinitionAdmin.GetParDefinition(DefFun.DefOutput, DefPar.DefOutput.MultiplyMonetaryBy));
cpr.Value = FixDecSep((1 / alpha).ToString());
}
else
{
CountryConfig.ParameterRow mpr_hh = fr_hh.GetParameterRows().First(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower());
double d;
if (!EM_Helpers.TryConvertToDouble(mpr_hh.Value, out d))
{
d = 1;
}
mpr_hh.Value = FixDecSep((d / alpha).ToString());
}
}
}
catch
{
throw new Exception("Problem in default output functions.");
}
}
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);
}
protected override void PrepareNonCommonPar()
{
if (!IsRunCondMet()) // note that this works for info that is clearly available at read-time, e.g. {IsUsedDatabase} or {1}
{
return; // but simply returns true for global variables, which may (in theory) change over run-time
}
// to handle the latter IsRunCond is called again in the Run-function (see below)
// consequently for e.g. {0} the variables are not even generated
// while for {$Const}, with $Const=0 at the point of request, the variables exist but are set to 0
// this also reflects the behaviour of the old executable
ParBase parSysYear = GetUniquePar <ParBase>(isConst ? DefPar.DefConst.Const_SystemYear : DefPar.DefVar.Var_SystemYear);
if (parSysYear != null && !EM_Helpers.DoesValueMatchPattern(parSysYear.xmlValue, infoStore.country.sys.year))
{
return;
}
ParBase parDataSet = GetUniquePar <ParBase>(isConst ? DefPar.DefConst.Const_Dataset : DefPar.DefVar.Var_Dataset);
if (parDataSet != null && !infoStore.IsUsedDatabase(parDataSet.xmlValue))
{
return;
}
foreach (var g in GetParGroups(isConst ? DefPar.DefConst.THE_ONLY_GROUP : DefPar.DefVar.THE_ONLY_GROUP))
{
List <ParBase> group = g.Value;
// global variables (DefConst) allow for parameter Condition (but there is no reason why it wouldn't work for DefVar as well, thus no check)
ParCond cond = GetUniqueGroupPar <ParCond>(DefPar.DefConst.Condition, group);
List <ParFormula> initFormulas = GetPlaceholderGroupPar <ParFormula>(group);
if (initFormulas.Count == 0) // there can be single Monetary parameters if definition is n/a for this system
{
continue;
}
if (cond == null && initFormulas.Count > 1)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{initFormulas[0].description.Get()}: multiple definition, group {g.Key} is already in use"
});
continue;
}
foreach (ParFormula initFormula in initFormulas)
{
string varName = initFormula.description.GetParName();
if (!EM_Helpers.IsValidName(varName, out string illegal))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{initFormula.description.Get()}: name contains illegal character(s) '{illegal}'"
});
continue;
}
if (isConst && cond == null && !initFormula.IsGlobal())
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true,
message = $"{initFormula.description.Get()}: trying to initialise global variable with a non-global amount"
});
}
bool isMonetary = false;
if (!isConst) // variables defined with DefConst cannot be monetary (more precisely, should not be added over TUs)
{
// if monetary-parameter is defined, use it, otherwise monetary=true (more precisely, get the default value from lib-def)
ParBool parMonetary = GetUniqueGroupPar <ParBool>(DefPar.DefVar.Var_Monetary, group);
isMonetary = parMonetary != null?parMonetary.GetBoolValue()
: DefinitionAdmin.GetParDefault <bool>(funName: DefFun.DefVar, parName: DefPar.DefVar.Var_Monetary);
}
if (!infoStore.operandAdmin.Exists(varName)) // double definition is not illegal (maybe questionable, but handled like this in old exe)
{
infoStore.operandAdmin.RegisterVar(name: varName, creatorFun: DefFun.DefVar, description: initFormula.description,
isMonetary: isMonetary,
isGlobal: isConst && cond == null,
isWriteable: true, // DefVar defined variables can be used as output-var (this is a bit lax with DefConst)
setInitialised: true); // DefVar defined variables always have an initial value -
// if user sets it n/a it does not exist, otherwise she needs to assign a value
// actual initialisation is done in the Run function
if (!infoStore.operandAdmin.Exists(varName))
{
continue; // registration failed
}
}
else if (infoStore.operandAdmin.GetCreatorFun(varName) != DefFun.DefVar && infoStore.operandAdmin.GetCreatorFun(varName) != DefFun.DefConst)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()} {varName}: {DefFun.DefVar}/{DefFun.DefConst} can only overwrite variables created by (another) {DefFun.DefVar}/{DefFun.DefConst}"
});
continue;
}
// variable cannot yet be initialised, as at this stage the hh-data does not exist (no formula interpretation possible yet)
// note on still setting the variable initialised at this stage, in context with the "not-initialised" warning:
// parameters are prepared in the spine-order, thus parameters which are prepared before would get a "not known"
// and parameters prepared afterwards are "legal" users
if (!varDefs.ContainsKey(varName))
{
varDefs.Add(varName, new List <VarDef>()); // see definition of varDefs for reason for Dictionary
}
varDefs[varName].Add(new VarDef()
{
varSpec = new VarSpec()
{
name = varName
}, initFormula = initFormula, condition = cond, groupNo = g.Key
});
}
}
// a variable can only be defined more than once within one function, if it is conditioned:
// only one definition can exist without a condition (which will be used as the default fallback value if conditions also exist)
foreach (List <VarDef> condConstDef in varDefs.Values)
{
if (condConstDef.Count > 1 && (from c in condConstDef where c.condition == null select c).Count() > 1)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()}: multiple definitions of {condConstDef[0].varSpec.name} without {DefPar.DefConst.Condition} found"
});
}
}
}
Dictionary <string, string> GatherComponents()
{
Dictionary <string, string> selectedComponents = new Dictionary <string, string>();
if (chkAllVariables.Checked)
{
if (chkCountrySpecific.Checked)
{
string countryShortName = _mainForm.GetCountryShortName();
foreach (VarConfig.VariableRow variableRow in EM_AppContext.Instance.GetVarConfigFacade().GetVariablesWithCountrySpecificDescription(countryShortName))
{
if (IsCheckedVariable(variableRow))
{
selectedComponents.Add(variableRow.Name, _componentType_Variable);
}
}
}
else if (chkMonetary.Checked || chkNonMonetary.Checked || chkSimulated.Checked || chkNonSimulated.Checked)
{
foreach (VarConfig.VariableRow variableRow in EM_AppContext.Instance.GetVarConfigFacade().GetVariables())
{
if (IsCheckedVariable(variableRow))
{
selectedComponents.Add(variableRow.Name, _componentType_Variable);
}
}
}
else
{
foreach (string variableName in EM_AppContext.Instance.GetVarConfigFacade().GetVariables_NamesAndDescriptions().Keys)
{
if (!selectedComponents.Keys.Contains(variableName.ToLower()))
{
selectedComponents.Add(variableName.ToLower(), _componentType_Variable);
}
}
}
}
if (chkAssessmentUnits.Checked)
{
List <CountryConfig.ParameterRow> parameterRowsTUs = null;
foreach (TreeListColumn systemColumn in _mainForm.GetTreeListBuilder().GetSystemColums())
{
CountryConfig.SystemRow systemRow = (systemColumn.Tag as SystemTreeListTag).GetSystemRow();
CountryConfigFacade.GetDefFunctionInformation(systemRow, ref parameterRowsTUs, DefFun.DefTu, DefPar.DefTu.Name);
foreach (CountryConfig.ParameterRow parameterRowsTU in parameterRowsTUs)
{
if (!selectedComponents.Keys.Contains(parameterRowsTU.Value.ToLower()))
{
selectedComponents.Add(parameterRowsTU.Value.ToLower(), _componentType_Taxunit);
}
}
}
}
if (chkIncomelists.Checked)
{
List <CountryConfig.ParameterRow> parameterRowsILs = null;
foreach (TreeListColumn systemColumn in _mainForm.GetTreeListBuilder().GetSystemColums())
{
CountryConfig.SystemRow systemRow = (systemColumn.Tag as SystemTreeListTag).GetSystemRow();
CountryConfigFacade.GetDefFunctionInformation(systemRow, ref parameterRowsILs, DefFun.DefIl, DefPar.DefIl.Name);
foreach (CountryConfig.ParameterRow parameterRowsIL in parameterRowsILs)
{
if (!selectedComponents.Keys.Contains(parameterRowsIL.Value.ToLower()))
{
selectedComponents.Add(parameterRowsIL.Value.ToLower(), _componentType_Incomelist);
}
}
}
}
if (chkQueries.Checked)
{
foreach (string queryName in DefinitionAdmin.GetQueryNamesAndDesc(false).Keys)
{
if (!selectedComponents.Keys.Contains(queryName.ToLower()))
{
selectedComponents.Add(queryName.ToLower(), _componentType_Query);
DefinitionAdmin.GetQueryDefinition(queryName, out DefinitionAdmin.Query queryDef, out string dummy, false);
if (queryDef != null)
{
foreach (string queryAlias in queryDef.aliases)
{
selectedComponents.Add(queryAlias.ToLower(), _componentType_Query);
}
}
}
}
}
if (txtComponentName.Text != string.Empty && !IsPatternSearchForSingleComponent()) //pattern-search has to be treated differently
{
if (!selectedComponents.Keys.Contains(txtComponentName.Text.ToLower()))
{
selectedComponents.Add(txtComponentName.Text.ToLower(), _componentType_Unknown);
}
}
return(selectedComponents);
}
internal override void CheckAndPrepare(FunBase fun)
{
ExtractStandardFootnotes(xmlValue, out string queryName, fun); // it is not impossible that #_Low/UpLim are applied on queries
// and #_Level may make good sense
DefinitionAdmin.GetQueryDefinition(queryName, out DefinitionAdmin.Query queryDef, out string queryMainName);
switch (queryMainName) // a query may have aliases, therefore GetQueryDefinition returns the "main"-name
{
case DefQuery.GetSystemYear: query = new QueryGetSystemYear(infoStore); break;
case DefQuery.GetDataIncomeYear: query = new QueryGetDataIncomeYear(infoStore); break;
case DefQuery.GetExchangeRate: query = new QueryGetExchangeRate(infoStore); break;
case DefQuery.GetPartnerIncome: query = new QueryGetPartnerIncome(infoStore); break;
case DefQuery.GetMotherIncome: query = new QueryGetMotherIncome(infoStore); break;
case DefQuery.GetFatherIncome: query = new QueryGetFatherIncome(infoStore); break;
case DefQuery.GetCoupleIncome: query = new QueryGetCoupleIncome(infoStore); break;
case DefQuery.GetParentsIncome: query = new QueryGetParentsIncome(infoStore); break;
case DefQuery.GetOwnChildrenIncome: query = new QueryGetOwnChildrenIncome(infoStore); break;
case DefQuery.HasMaxValInTu: query = new QueryHasMaxValInTu(infoStore); break;
case DefQuery.HasMinValInTu: query = new QueryHasMinValInTu(infoStore); break;
case DefQuery.IsHeadOfTu: query = new QueryIsHead(infoStore); break;
case DefQuery.IsMarried: query = new QueryIsMarried(infoStore); break;
case DefQuery.IsCohabiting: query = new QueryIsCohabiting(infoStore); break;
case DefQuery.IsWithPartner: query = new QueryIsWithPartner(infoStore); break;
case DefQuery.IsUsedDatabase: query = new QueryIsUsedDatabase(infoStore); break;
case DefQuery.IsNtoMchild: query = new QueryIsNtoMChild(infoStore); break;
case DefQuery.IsParent: query = new QueryIsParent(infoStore); break;
case DefQuery.IsParentOfDepChild: query = new QueryIsParentOfDepChild(infoStore); break;
case DefQuery.IsInEducation: query = new QueryIsInEducation(infoStore); break;
case DefQuery.IsDisabled: query = new QueryIsDisabled(infoStore); break;
case DefQuery.IsPartner: query = new QueryIsPartner(infoStore); break;
case DefQuery.IsDepChild: query = new QueryIsDepChild(infoStore); break;
case DefQuery.IsOwnChild: query = new QueryIsOwnChild(infoStore); break;
case DefQuery.IsOwnDepChild: query = new QueryIsOwnDepChild(infoStore); break;
case DefQuery.IsLooseDepChild: query = new QueryIsLooseDepChild(infoStore); break;
case DefQuery.IsDepParent: query = new QueryIsDepParent(infoStore); break;
case DefQuery.IsDepRelative: query = new QueryIsDepRelative(infoStore); break;
case DefQuery.IsLoneParentOfDepChild: query = new QueryIsLoneParentOfDepChild(infoStore); break;
case DefQuery.IsCivilServant: query = new QueryIsCivilServant(infoStore); break;
case DefQuery.IsBlueColl: query = new QueryIsBlueColl(infoStore); break;
case DefQuery.IsOutputCurrencyEuro: query = new QueryIsOutputCurrencyEuro(infoStore); break;
case DefQuery.IsParamCurrencyEuro: query = new QueryIsParamCurrencyEuro(infoStore); break;
case DefQuery.IsLoneParent: query = new QueryIsLoneParent(infoStore); break;
case DefQuery.nChildrenOfCouple: query = new QueryNChildrenOfCouple(infoStore); break;
case DefQuery.nDepChildrenOfCouple: query = new QueryNDepChildrenOfCouple(infoStore); break;
case DefQuery.nAdultsInTu: query = new QueryNAdultsInTu(infoStore); break;
case DefQuery.nDepChildrenInTu: query = new QueryNDepChildrenInTu(infoStore); break;
case DefQuery.nLooseDepChildrenInTu: query = new QueryNLooseDepChildrenInTu(infoStore); break;
case DefQuery.nDepParentsInTu: query = new QueryNDepParentsInTu(infoStore); break;
case DefQuery.nDepRelativesInTu: query = new QueryNDepRelativesInTu(infoStore); break;
case DefQuery.nDepParentsAndRelativesInTu: query = new QueryNDepParentsAndRelativesInTu(infoStore); break;
case DefQuery.nPersInUnit: query = new QueryNPersInUnit(infoStore); break;
case DefQuery.rand: query = new QueryRand(infoStore); break;
default: // the query must be defined in DefQuery, otherwise there wouldn't be a ParQuery-parameter, but it seems to be not implemented)
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $"{description.Get()}: usage of not implemented query {queryName}"
});
return;
}
isGlobal = queryDef.isGlobal;
query.description = new Description(description, queryName);
query.CheckAndPrepare(fun, GetFootnoteNumbers(xmlValue, out string dummy));
}
internal void PrepareSpine(ref bool runSequential)
{
string BEFORE = "BEFORE", AFTER = "AFTER", IN = "IN", spineState = BEFORE;
FunBase causeForSequential = null, prevFun = null;
if (!runSequential)
{
foreach (FunBase fun in infoStore.spine.Values)
{
switch (DefinitionAdmin.GetFunDefinition(fun.description.GetFunName()).runMode)
{
case DefFun.RUN_MODE.NOT_APPLICABLE: continue;
case DefFun.RUN_MODE.IN_SPINE:
if (spineState == AFTER)
{
runSequential = true; causeForSequential = prevFun;
}
else
{
spineState = IN; runInSpine.Add(fun);
}
break;
case DefFun.RUN_MODE.OUTSIDE_SPINE:
if (spineState == IN)
{
spineState = AFTER;
}
if (spineState == AFTER)
{
runAfterSpine.Add(fun as FunOutOfSpineBase);
}
else
{
runBeforeSpine.Add(fun as FunOutOfSpineBase);
}
break;
}
if (runSequential)
{
break;
}
prevFun = fun;
}
}
if (runSequential)
{
runBeforeSpine.Clear(); runAfterSpine.Clear(); runInSpine.Clear();
foreach (FunBase fun in infoStore.spine.Values)
{
if (DefinitionAdmin.GetFunDefinition(fun.description.GetFunName()).runMode != DefFun.RUN_MODE.NOT_APPLICABLE)
{
runInSpine.Add(fun);
}
}
string cause = causeForSequential == null ? "Forcing sequential" : $"{causeForSequential.description.Get()}: usage inside spine";
infoStore.communicator.ReportProgress(new Communicator.ProgressInfo()
{
message = cause + " causes (slightly) slower run"
});
}
// organise loop-handling (if there is/are any)
foreach (FunBase fun in infoStore.spine.Values)
{
if (fun is FunLoop)
{
FunLoop funLoop = fun as FunLoop;
if (!funLoop.GetRange(runInSpine) || IsLoopIntersection(funLoop))
{
continue;
}
// put loops into Dictionaries that allow LoopyGetNextFun to recognise that it needs to "talk" to the loops (when it hits start or end)
// if there are several loops with the same last function (nested loops) they are sorted reversly
// by their first function, in order to "ask" the inner loop first, if there should be a jump back
if (!loopEnds.ContainsKey(funLoop.indexLastFun))
{
loopEnds.Add(funLoop.indexLastFun, new SortedList <double, FunLoop>());
}
double iSort = funLoop.indexFirstFun; // if loops have the same start and end, make the first declared the outer
while (loopEnds[funLoop.indexLastFun].ContainsKey(iSort * (-1)))
{
iSort += 0.001;
}
loopEnds[funLoop.indexLastFun].Add(iSort * (-1), funLoop);
// similar holds for loops with the same start, they need to be sorted reversly by their last function
// in order to ask the outer loop first, if there should be a jump over
if (!loopStarts.ContainsKey(funLoop.indexFirstFun))
{
loopStarts.Add(funLoop.indexFirstFun, new SortedList <double, FunLoop>());
}
iSort = funLoop.indexLastFun; // see above, wrt to loops with same start and end
while (loopStarts[funLoop.indexFirstFun].ContainsKey(iSort * (-1)))
{
iSort -= 0.001;
}
loopStarts[funLoop.indexFirstFun].Add(iSort * (-1), funLoop);
}
}
}
Dictionary <string, string> GetAddFunctionMenuItems(string policyName)
{
//assess if policy is a system policy or a regular policy
//string kind = FunctionConfigFacade.functionTypePolicy;
DefinitionAdmin.Fun.KIND kind = DefinitionAdmin.Fun.KIND.POLICY;
foreach (string systemPolicyName in DefPol.GetSystemPolicies())
{
if (policyName.ToLower().Contains(systemPolicyName.ToLower()))
{
kind = DefinitionAdmin.Fun.KIND.SYSTEM;
}
}
//assess if policy has (a) related function(s), e.g. policy 'ILDef_cc' <-> function 'DefIL'
Dictionary <string, string> menuItemNamesAndDescriptions = DefinitionAdmin.GetPolRelatedFuns(policyName);
if (menuItemNamesAndDescriptions.Count > 0)
{
menuItemNamesAndDescriptions.Add("#1", _menuItemCaption_OtherSystemFunctions); //# marks a drop-down menu, the number is just because dictionaries don't accept equal keys
}
//get 'main functions', i.e. policy functions for regular policies and system functions for system functions
//(for system policies with related functions the latter appear under the header 'other system functions')
Dictionary <string, string> functionsOfKind = DefinitionAdmin.GetFunNamesAndDesc(kind);
foreach (string functionOfKind in functionsOfKind.Keys)
{
if (!menuItemNamesAndDescriptions.ContainsKey(functionOfKind))
{
menuItemNamesAndDescriptions.Add(functionOfKind, functionsOfKind[functionOfKind]);
}
}
//now get 'subordered functions', i.e. system functions for regular policies and policy functions for system policies
if (kind == DefinitionAdmin.Fun.KIND.POLICY)
{
menuItemNamesAndDescriptions.Add("#2", _menuItemCaption_SystemFunctions);
kind = DefinitionAdmin.Fun.KIND.SYSTEM;
}
else
{
menuItemNamesAndDescriptions.Add("#2", _menuItemCaption_PolicyFunctions);
kind = DefinitionAdmin.Fun.KIND.POLICY;
}
functionsOfKind = DefinitionAdmin.GetFunNamesAndDesc(kind);
foreach (string functionOfKind in functionsOfKind.Keys)
{
menuItemNamesAndDescriptions.Add(functionOfKind, functionsOfKind[functionOfKind]);
}
//finally get special functions ...
menuItemNamesAndDescriptions.Add("#3", _menuItemCaption_SpecialFunctions);
functionsOfKind = DefinitionAdmin.GetFunNamesAndDesc(DefinitionAdmin.Fun.KIND.SPECIAL);
foreach (string functionOfKind in functionsOfKind.Keys)
{
menuItemNamesAndDescriptions.Add(functionOfKind, functionsOfKind[functionOfKind]);
}
//... and add-on-functions if window shows an add-on and the policy is the ao_control_-policy (i.e. the only policy that can contain these functions)
if (_mainForm._isAddOn && policyName.ToLower().StartsWith(ExeXml.AddOn.POL_AO_CONTROL.ToLower()))
{
menuItemNamesAndDescriptions.Add("#4", _menuItemCaption_AddOnFunctions);
functionsOfKind = DefinitionAdmin.GetFunNamesAndDesc(DefinitionAdmin.Fun.KIND.ADDON);
foreach (string functionOfKind in functionsOfKind.Keys)
{
menuItemNamesAndDescriptions.Add(functionOfKind, functionsOfKind[functionOfKind]);
}
}
return(menuItemNamesAndDescriptions);
}
List <IntelliItem> GetIntelliItems()
{
List <IntelliItem> intelliItems = new List <IntelliItem>();
intelliItems.Clear();
try
{
if (_treeList.FocusedNode.Tag == null)
{
return(intelliItems); //should not happen
}
BaseTreeListTag nodeTag = _treeList.FocusedNode.Tag as BaseTreeListTag;
SystemTreeListTag systemTag = null;
//first assess which intelli-items should be shown in dependece of the edited cell ...
List <int> specficIntelliItems = null;
if (TreeListBuilder.IsPolicyColumn(_treeList.FocusedColumn)) //editited cell is an exceptionally editable policy-column-cell (e.g. functions DefIL, DefConst, SetDefault, etc.)
{
//take system specific intelli-items (e.g. incomelists) from any existing system, as one cannot know for which system the user wants to define the parameter
TreeListColumn anySystemColumn = _treeList.Columns.ColumnByName(nodeTag.GetDefaultPolicyRow().SystemRow.Name);
if (anySystemColumn != null)
{
systemTag = anySystemColumn.Tag as SystemTreeListTag;
}
//in dependence of the function define the available intelli-items (e.g. only variables or variables and incomelists, etc.)
specficIntelliItems = GetIntelliItemsForEditablePolicyColumn(nodeTag.GetDefaultFunctionRow().Name);
}
else if (TreeListBuilder.IsSystemColumn(_treeList.FocusedColumn))
{
//in dependence of the parameter-value-type define the available intelli-items (usually everything, but e.g. for output_variables only variables)
systemTag = _treeList.FocusedColumn.Tag as SystemTreeListTag;
specficIntelliItems = nodeTag.GetTypeSpecificIntelliItems(systemTag);
}
else
{
return(intelliItems); //should not happen
}
//... then gather the respective intelli-items
//constants defined by function DefConst
if ((specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsDefConst)) && systemTag != null)
{
foreach (DataSets.CountryConfig.ParameterRow parameterRow in systemTag.GetParameterRowsConstants())
{
if (parameterRow.Name.ToLower() == DefPar.DefVar.EM2_Var_Name.ToLower())
{
intelliItems.Add(new IntelliItem(parameterRow.Value, parameterRow.Comment, _intelliImageConstant));
}
else if (parameterRow.Name.ToLower() == DefPar.DefConst.Condition.ToLower())
{
continue;
}
else
{
intelliItems.Add(new IntelliItem(parameterRow.Name, GetConstDescription(parameterRow) + " " + parameterRow.Comment, _intelliImageConstant));
}
}
}
//variables defined by function DefVar
if ((specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsDefVar)) && systemTag != null)
{
foreach (DataSets.CountryConfig.ParameterRow parameterRow in systemTag.GetParameterRowsDefVariables())
{
if (parameterRow.Name.ToLower() == DefPar.DefVar.EM2_Var_Name.ToLower())
{
intelliItems.Add(new IntelliItem(parameterRow.Value, parameterRow.Comment, _intelliImageVariable));
}
else
{
intelliItems.Add(new IntelliItem(parameterRow.Name, parameterRow.Comment, _intelliImageVariable));
}
}
}
// uprating factors
if (specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsUpRateFactor))
{
string cc = EM_AppContext.Instance.GetActiveCountryMainForm().GetCountryShortName();
CountryConfigFacade ccf = CountryAdministration.CountryAdministrator.GetCountryConfigFacade(cc);
foreach (CountryConfig.UpratingIndexRow ur in ccf.GetUpratingIndices())
{
intelliItems.Add(new IntelliItem(ur.Reference, ur.Description, _intelliImageConstant));
}
}
//standard variables defined in VarConfig (idhh, yem, poa, ...)
if (specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsStandardVar))
{
string countryShortName = systemTag == null ? string.Empty : systemTag.GetSystemRow().CountryRow.ShortName;
Dictionary <string, string> standardVariables = EM_AppContext.Instance.GetVarConfigFacade().GetVariables_NamesAndDescriptions(countryShortName);
foreach (string standardVariable in standardVariables.Keys)
{
intelliItems.Add(new IntelliItem(standardVariable, standardVariables[standardVariable], _intelliImageVariable));
}
}
//incomelists defined by function DefIL
if ((specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsDefIL)) && systemTag != null)
{
foreach (DataSets.CountryConfig.ParameterRow parameterRow in systemTag.GetParameterRowsILs())
{
intelliItems.Add(new IntelliItem(parameterRow.Value, systemTag.GetILTUComment(parameterRow), _intelliImageIL));
}
}
//queries (IsDepChild, ...)
if (specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsQueries))
{
foreach (var q in DefinitionAdmin.GetQueryNamesAndDesc())
{
string queryName = q.Key, queryDesc = q.Value;
intelliItems.Add(new IntelliItem(queryName, queryDesc, _intelliImageConfiguration)); //first add normally ...
intelliItems.Add(new IntelliItem(_queryPrefix + queryName, //.. then add with query prefix to allow users to see all available queries (is removed before query is inserted)
queryDesc, _intelliImageConfiguration));
}
}
//footnotes
if (specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsFootnotes))
{
//placeholders for new footnote parameters (#x1[_Level], #x2[_UpLim], etc.)
Dictionary <string, string> footnotes = GetFootnoteParametersForIntelli();
foreach (string footnote in footnotes.Keys)
{
intelliItems.Add(new IntelliItem(footnote, footnotes[footnote], _intelliImageFootnote));
}
//existing footnote amount parameters (#_Amount reverserd to Amount#x)
footnotes = TreeListManager.GetFunctionsExistingAmountParameters(_treeList.FocusedNode.ParentNode, _treeList.FocusedColumn.GetCaption());
foreach (string footnote in footnotes.Keys)
{
intelliItems.Add(new IntelliItem(footnote, footnotes[footnote], _intelliImageFootnote));
}
//other existing footnote parameters (#_Level, #_UpLim, etc.)
footnotes = TreeListManager.GetFunctionsExistingFootnoteParameters(_treeList.FocusedNode.ParentNode, _treeList.FocusedColumn.GetCaption());
foreach (string footnote in footnotes.Keys)
{
intelliItems.Add(new IntelliItem(footnote, footnotes[footnote], _intelliImageFootnote));
}
}
if (specficIntelliItems == null || specficIntelliItems.Contains(_intelliContainsRandAbsMinMax))
{
intelliItems.Add(new IntelliItem("rand", "Random number", _intelliImageConfiguration));
intelliItems.Add(new IntelliItem("<abs>()", "Absolute value operator", _intelliImageConfiguration));
intelliItems.Add(new IntelliItem("<min> ", "Minimum operator", _intelliImageConfiguration));
intelliItems.Add(new IntelliItem("<max> ", "Maximum operator", _intelliImageConfiguration));
}
// special case for parameter DefTU/Members: show the options, e.g. Partner, OwnDepChild, ...
if (specficIntelliItems != null && specficIntelliItems.Contains(_intelliContainsDefTUMembers))
{
ParameterTreeListTag parTag = nodeTag as ParameterTreeListTag;
if (parTag != null)
{
foreach (string tuMember in new List <string>()
{
DefPar.DefTu.MEMBER_TYPE.PARTNER_CAMEL_CASE, DefPar.DefTu.MEMBER_TYPE.OWNCHILD_CAMEL_CASE,
DefPar.DefTu.MEMBER_TYPE.DEPCHILD_CAMEL_CASE, DefPar.DefTu.MEMBER_TYPE.OWNDEPCHILD_CAMEL_CASE, DefPar.DefTu.MEMBER_TYPE.LOOSEDEPCHILD_CAMEL_CASE,
DefPar.DefTu.MEMBER_TYPE.DEPPARENT_CAMEL_CASE, DefPar.DefTu.MEMBER_TYPE.DEPRELATIVE_CAMEL_CASE
})
{
intelliItems.Add(new IntelliItem(tuMember, string.Empty, _intelliImageConfiguration));
}
}
}
//taxunits defined by function DefTU: only for add-ons, which use formulas for all parameters (i.e. also for taxunit parameters)
if ((_treeList.Parent as EM_UI_MainForm)._isAddOn && systemTag != null)
{
foreach (DataSets.CountryConfig.ParameterRow parameterRow in systemTag.GetParameterRowsTUs())
{
intelliItems.Add(new IntelliItem(parameterRow.Value, systemTag.GetILTUComment(parameterRow), _intelliImageTU));
}
}
return(intelliItems);
}
catch
{
//do not jeopardise the UI-stability because IntelliItems cannot be gathered but try if problem can be fixed by updating the info
UpdateInfo();
return(intelliItems);
}
List <int> GetIntelliItemsForEditablePolicyColumn(string functionName)
{
functionName = functionName.ToLower();
List <int> items = new List <int>();
if (functionName == DefFun.SetDefault.ToLower() || functionName == DefFun.Uprate.ToLower())
{
items.Add(_intelliContainsStandardVar);
items.Add(_intelliContainsDefVar); //not sure whether variables defined by DefVar should be displayed (?)
}
if (functionName == DefFun.DefIl.ToLower())
{
items.Add(_intelliContainsStandardVar);
items.Add(_intelliContainsDefVar);
items.Add(_intelliContainsDefConst);
items.Add(_intelliContainsDefIL);
}
//other functions with editable policy column (DefConst, DefVar): no intelliItems (i.e. no suggestions for e.g. constant names)
return(items);
}
}
