private void PrepareIterationPar()
{
ParTU parEligUnit = GetUniquePar <ParTU>(DefPar.UnitLoop.Elig_Unit); if (parEligUnit != null)
{
eligUnit = parEligUnit.name;
}
parEligUnitCond = GetUniquePar <ParCond>(DefPar.UnitLoop.Elig_Unit_Cond);
ParCateg parWho = GetUniquePar <ParCateg>(DefPar.UnitLoop.Elig_Unit_Cond_Who); if (parWho != null)
{
who = parWho.GetCateg();
}
}
/// <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"
});
}
}
}
protected override void PrepareNonCommonPar()
{
// get parameters
ParIL parOperatorIL = GetUniquePar <ParIL>(DefPar.IlVarOp.Operator_IL); if (parOperatorIL == null)
{
return; // error is handled by global check
}
ParFormula parOperand = GetUniquePar <ParFormula>(DefPar.IlVarOp.Operand);
bool useFactors = GetParBoolValueOrDefault(DefFun.IlVarOp, DefPar.IlVarOp.Operand_Factors);
ParIL parOperandIL = GetUniquePar <ParIL>(DefPar.IlVarOp.Operand_IL);
ParCateg parMulAdd = GetUniquePar <ParCateg>(DefPar.IlVarOp.Operation); if (parMulAdd != null)
{
mulAdd = parMulAdd.GetCateg();
}
ParCateg parSelVar = GetUniquePar <ParCateg>(DefPar.IlVarOp.Sel_Var); if (parSelVar != null)
{
selVar = parSelVar.GetCateg();
}
// assess what to do and check for insufficient or contradictory information
if (parOperand != null)
{
//if (parOperand.IsGlobal()) opTask = OPERAND_TYPE.SCALAR; // out-commented to replace by the weaker condtion below, otherwise it produces an error with constants
if (double.TryParse(parOperand.xmlValue, out double x))
{
opTask = OPERAND_TYPE.SCALAR;
}
else
{
opTask = OPERAND_TYPE.FORMULA; formulaOperand = parOperand;
}
}
else if (parOperandIL != null)
{
if (!CheckDoubleDef(OPERAND_TYPE.IL))
{
return;
}
}
if (useFactors)
{
if (!CheckDoubleDef(OPERAND_TYPE.FACTORS))
{
return;
}
}
if (mulAdd == DefPar.Value.ILVAROP_NEGTOZERO)
{
if (!CheckDoubleDef(OPERAND_TYPE.NEGTOZERO))
{
return;
}
}
if (opTask == OPERAND_TYPE.INVALID)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()}: missing definition of operand"
});
return;
}
if (opTask == OPERAND_TYPE.IL && parOperandIL.GetFlatContent().Count != parOperatorIL.GetFlatContent().Count)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()}: incomelists {parOperatorIL.name} and {parOperandIL.name} do not have the same number of variables, operation is not possible"
});
return;
}
// prepare information for run
for (int i = 0; i < parOperatorIL.GetFlatContent().Count; ++i)
{
OpItem oi = new OpItem()
{
varOperator = parOperatorIL.GetFlatContent()[i].varSpec
};
switch (opTask)
{
case OPERAND_TYPE.FACTORS: oi.numOperand = parOperatorIL.GetFlatContent()[i].addFactor; break;
case OPERAND_TYPE.SCALAR: oi.numOperand = parOperand.GetGlobalValue(); break;
case OPERAND_TYPE.IL: oi.varOperand = parOperandIL.GetFlatContent()[i].varSpec; break;
}
opItems.Add(oi);
}
bool CheckDoubleDef(OPERAND_TYPE ot)
{
if (opTask == OPERAND_TYPE.INVALID)
{
opTask = ot; return(true);
}
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()}: contradictory definition of operand"
});
return(false);
}
}
protected void PrepareLimPar()
{
coParLowLim = GetUniquePar <ParFormula>(DefPar.Common.LowLim);
coParUpLim = GetUniquePar <ParFormula>(DefPar.Common.UpLim);
coParThres = GetUniquePar <ParFormula>(DefPar.Common.Threshold);
ParCateg coParLimpriority = GetUniquePar <ParCateg>(DefPar.Common.Limpriority);
// the following tries to optimise by getting the values here, if they are read-time-available (e.g. 600#y, GetSystemYear, ...)
// and by checking for implausible values (e.g. upLim = 10, lowLim = 100) if already possible
if (coParLowLim != null)
{
if (coParLowLim.IsGlobal(true))
{
lowLim = coParLowLim.GetGlobalValue(); coParLowLim = null;
}
else
{
doRunTimeLimCheck = true;
}
}
if (coParUpLim != null)
{
if (coParUpLim.IsGlobal(true))
{
upLim = coParUpLim.GetGlobalValue(); coParUpLim = null;
}
else
{
doRunTimeLimCheck = true;
}
}
bool checkThres = coParThres != null;
if (coParThres != null)
{
if (coParThres.IsGlobal(true))
{
thres = coParThres.GetGlobalValue(); coParThres = null;
}
else
{
doRunTimeThresCheck = true;
}
}
if (coParLimpriority != null)
{
limPri = coParLimpriority.GetCateg();
}
if (!doRunTimeLimCheck) // both limits available (might be double.MinValue and/or double.MaxValue, but does no harm here)
{
CheckLimits(ref lowLim, ref upLim);
if (checkThres && !doRunTimeThresCheck) // threshold and both limits available
{
if (!CheckThreshold(thres, lowLim, upLim))
{
thres = lowLim;
}
}
}
}
protected override void PrepareNonCommonPar()
{
ParCateg parType = GetUniquePar <ParCateg>(DefPar.DefTu.Type);
if (parType != null)
{
tuType = parType.GetCateg();
}
if (tuType != DefPar.Value.TUTYPE_IND)
{
// get the INCOME used to define the head
headDefInc = GetUniquePar <ParVarIL>(DefPar.DefTu.HeadDefInc);
if (headDefInc == null) // if no income defined, use ils_origy as default
{
headDefInc = new ParVarIL(infoStore);
headDefInc.xmlValue = infoStore.country.sys.headDefInc == string.Empty ? DefVarName.ILSORIGY : infoStore.country.sys.headDefInc;
headDefInc.description = description;
headDefInc.CheckAndPrepare(this);
}
// get all the conditions and set the defaults if they did not exist before
if (extHeadCond == null)
{
extHeadCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.EXTHEAD, description = description
};
extHeadCond.CheckAndPrepare(this);
}
}
if (partnerCond == null)
{
partnerCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.PARTNER, description = description
};
partnerCond.CheckAndPrepare(this);
}
if (depChildCond == null)
{
depChildCond = new ParCond(infoStore)
{
xmlValue = "{0}", description = description
};
depChildCond.CheckAndPrepare(this);
}
if (ownChildCond == null)
{
ownChildCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.OWNCHILD, description = description
};
ownChildCond.CheckAndPrepare(this);
}
if (ownDepChildCond == null)
{
ownDepChildCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.OWNDEPCHILD, description = description
};
ownDepChildCond.CheckAndPrepare(this);
}
if (looseDepChildCond == null)
{
looseDepChildCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.LOOSEDEPCHILD, description = description
};
looseDepChildCond.CheckAndPrepare(this);
}
if (depParentCond == null)
{
depParentCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.DEPPARENT, description = description
};
depParentCond.CheckAndPrepare(this);
}
if (depRelativeCond == null)
{
depRelativeCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.DEPRELATIVE, description = description
};
depRelativeCond.CheckAndPrepare(this);
}
if (loneParentCond == null)
{
loneParentCond = new ParCond(infoStore)
{
xmlValue = DefPar.DefTu.DEFAULT_CONDITION.LONEPARENT, description = description
};
loneParentCond.CheckAndPrepare(this);
}
// get all the booleans and set the values
ParBool noChildIfHeadPar = GetUniquePar <ParBool>(DefPar.DefTu.NoChildIfHead);
noChildIfHead = noChildIfHeadPar != null && noChildIfHeadPar.GetBoolValue();
ParBool noChildIfPartnerPar = GetUniquePar <ParBool>(DefPar.DefTu.NoChildIfPartner);
noChildIfPartner = noChildIfPartnerPar != null && noChildIfPartnerPar.GetBoolValue();
ParBool assignDepChOfDependentsPar = GetUniquePar <ParBool>(DefPar.DefTu.AssignDepChOfDependents);
assignDepChOfDependents = assignDepChOfDependentsPar != null && assignDepChOfDependentsPar.GetBoolValue();
ParBool assignPartnerOfDependentsPar = GetUniquePar <ParBool>(DefPar.DefTu.AssignPartnerOfDependents);
assignPartnerOfDependents = assignPartnerOfDependentsPar != null && assignPartnerOfDependentsPar.GetBoolValue();
ParBool stopIfNoHeadFoundPar = GetUniquePar <ParBool>(DefPar.DefTu.StopIfNoHeadFound);
stopIfNoHeadFound = stopIfNoHeadFoundPar != null && stopIfNoHeadFoundPar.GetBoolValue();
ParCateg multiplePartnersPar = GetUniquePar <ParCateg>(DefPar.DefTu.MultiplePartners);
multiplePartners = multiplePartnersPar == null ? string.Empty : multiplePartnersPar.GetCateg();
}
protected void PrepareEligPar()
{
coParWho = GetUniquePar <ParCateg>(DefPar.Common.Who_Must_Be_Elig);
coParEligVar = GetUniquePar <ParVar>(DefPar.Common.Elig_Var);
}
/// <summary>
/// checks if the standard footnote-parameters, i.e. #_LowLim, #_UpLim, #_Level, are applied on the parameter
/// if so, stores them in lowLim, upLim and alternativeTU (see above)
/// also provides the "cleaned" value (e.g. yem#1 -> yem)
/// note that the footnote-parameters are assessed via the (mother)function (parameter fun)
/// also note that the only other (not here handled) footnote-parameters are 'amount', which is handled by ParFormula
/// and query parameters which will not issue a "missing" (see below) but let the query check if it can use the footnote
/// </summary>
protected void ExtractStandardFootnotes(string value, out string cleanedValue, FunBase fun)
{
List <string> numbers = GetFootnoteNumbers(value, out cleanedValue); // it's unlikely, but yem#1#3 is possible (see GetFootnoteNumbers)
if (numbers.Count == 0)
{
return; // no footnotes
}
// limits (see remark in _FunInSpineBase_Lim wrt not using a common implementation for limits)
pLowLim = fun.GetFootnotePar <ParFormula>(DefPar.Footnote.LowLim, numbers);
if (pLowLim != null)
{
if (pLowLim.IsGlobal(true))
{
lowLim = pLowLim.GetGlobalValue(); pLowLim = null;
}
else
{
doRunTimeLimCheck = true;
}
}
pUpLim = fun.GetFootnotePar <ParFormula>(DefPar.Footnote.UpLim, numbers);
if (pUpLim != null)
{
if (pUpLim.IsGlobal(true))
{
upLim = pUpLim.GetGlobalValue(); pUpLim = null;
}
else
{
doRunTimeLimCheck = true;
}
}
ParCateg pLimpriority = fun.GetFootnotePar <ParCateg>(DefPar.Footnote.LimPriority, numbers);
if (pLimpriority != null)
{
limPri = pLimpriority.GetCateg();
}
if (!doRunTimeLimCheck) // both limits available (might be double.MinValue and/or double.MaxValue, but does no harm here)
{
CheckLimits(ref lowLim, ref upLim);
}
// alternative TU
ParBase parAltTU = fun.GetFootnotePar <ParBase>(DefPar.Footnote.Level, numbers);
if (parAltTU != null)
{
alternativeTU = parAltTU.xmlValue;
}
// if none of the standard footnotes is defined in the function #x points to nowhere ...
if (GetType() == typeof(ParQuery)) // ... except for queries, which may have own footnotes
{
return; // (this is slightly negligent, as it accepts e.g. IsMarried#1 without respective footnote-parameter)
}
if (pLowLim == null && lowLim == double.MinValue &&
pUpLim == null && upLim == double.MaxValue &&
parAltTU == null)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true, message = $"{description.Get()}: missing footnote parameter for {value}"
});
}
}
protected override void PrepareNonCommonPar()
{
aggs = GetNonUniquePar <ParVarIL>(DefPar.Totals.Agg);
if (aggs.Count == 0)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false, message = $"{description.Get()}: missing required parameter AGG"
});
return;
}
foreach (string t in new List <string> {
DefPar.Totals.Varname_Sum, DefPar.Totals.Varname_Mean, DefPar.Totals.Varname_Median,
DefPar.Totals.Varname_Decile, DefPar.Totals.Varname_Quintile, DefPar.Totals.Varname_Count, DefPar.Totals.Varname_PosCount,
DefPar.Totals.Varname_NegCount, DefPar.Totals.Varname_Min, DefPar.Totals.Varname_Max
})
{
ParBase par = GetUniquePar <ParBase>(t); if (par == null)
{
continue;
}
actions.Add(t);
foreach (ParVarIL agg in aggs)
{
string aggName = agg.GetName();
agg.CheckAndPrepare(this);
int n = 1; if (t == DefPar.Totals.Varname_Decile)
{
n = 9;
}
if (t == DefPar.Totals.Varname_Quintile)
{
n = 4;
}
for (int i = 1; i <= n; ++i)
{
string counter = t == DefPar.Totals.Varname_Decile || t == DefPar.Totals.Varname_Quintile ? i.ToString() : string.Empty;
string varName = $"{par.xmlValue}{counter}_{aggName}";
infoStore.operandAdmin.RegisterVar( // generate the variable that will take the total
name: varName,
creatorFun: DefFun.Totals,
description: par.description,
isMonetary: false, // not really clear, but adding over TU does not make sense
isGlobal: true, // equal for each person
isWriteable: false, // cannot be use as output-variable
setInitialised: true);
if (infoStore.operandAdmin.Exists(varName))
{
totals.Add(t + (n > 1 ? i.ToString() : "") + aggName, new VarSpec()
{
name = varName
});
}
}
}
}
// setup booleans
hasMedian = actions.Contains(DefPar.Totals.Varname_Median);
hasQuint = actions.Contains(DefPar.Totals.Varname_Quintile);
hasDec = actions.Contains(DefPar.Totals.Varname_Decile);
hasSum = actions.Contains(DefPar.Totals.Varname_Sum);
hasMean = actions.Contains(DefPar.Totals.Varname_Mean);
// check if there is a condition for inclusion
ParCond inclCond = GetUniquePar <ParCond>(DefPar.Totals.Incl_Cond);
if (inclCond != null)
{
ParCateg inclWho = GetUniquePar <ParCateg>(DefPar.Totals.Incl_Cond_Who);
string inclWhoVal = (inclWho == null) ? DefPar.Value.WHO_ALL : inclWho.GetCateg();
include = new Tuple <ParCond, string>(inclCond, inclWhoVal);
}
// check if results should be weighted
useWeights = GetParBoolValueOrDefault(DefFun.Totals, DefPar.Totals.Use_Weights);
if (useWeights) // get the weight var, if null use dwt
{
ParVar dwtPar = GetUniquePar <ParVar>(DefPar.Totals.Weight_Var);
dwtName = dwtPar != null ? dwtPar.name : DefVarName.DWT;
infoStore.operandAdmin.CheckRegistration(dwtName, false, false, description);
}
//
}
protected override void PrepareNonCommonPar()
{
ParVar fv = GetUniquePar <ParVar>(DefPar.AddHHMembers.FlagVar);
if (fv != null)
{
flagVar = new VarSpec()
{
name = fv.name
}
}
;
foreach (var g in GetParGroups(DefPar.AddHHMembers.GROUP_MAIN))
{
var group = g.Value; int groupNo = g.Key;
AddInstruction addInstruction = new AddInstruction();
// first find out whether we are adding children or partners or other persons ...
ParCateg parWho = GetUniqueGroupPar <ParCateg>(DefPar.AddHHMembers.Add_Who, group); if (parWho == null)
{
continue; // compulsory parameter, error already issued
}
addInstruction.addWho = parWho.GetCateg();
// ... depending on that, check the add-condition
ParCond parParent = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.ParentCond, group);
ParCond parPartner = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.PartnerCond, group);
ParCond parOther = GetUniqueGroupPar <ParCond>(DefPar.AddHHMembers.HHCond, group);
string missing = string.Empty; string tooMuch = string.Empty;
switch (addInstruction.addWho)
{
case DefPar.Value.ADDHHMEMBERS_CHILD:
if (parParent != null)
{
addInstruction.cond = parParent;
}
else
{
missing = DefPar.AddHHMembers.ParentCond;
}
if (parPartner != null)
{
tooMuch = DefPar.AddHHMembers.PartnerCond + " ";
}
if (parOther != null)
{
tooMuch = DefPar.AddHHMembers.HHCond;
}
ParBool parIsPP = GetUniqueGroupPar <ParBool>(DefPar.AddHHMembers.IsPartnerParent, group);
if (parIsPP != null)
{
addInstruction.isPartnerParent = parIsPP.GetBoolValue();
}
break;
case DefPar.Value.ADDHHMEMBERS_PARTNER:
if (parParent != null)
{
tooMuch = DefPar.AddHHMembers.ParentCond + " ";
}
if (parPartner != null)
{
addInstruction.cond = parPartner;
}
else
{
missing = DefPar.AddHHMembers.PartnerCond;
}
if (parOther != null)
{
tooMuch = DefPar.AddHHMembers.HHCond;
}
break;
case DefPar.Value.ADDHHMEMBERS_OTHER:
if (parParent != null)
{
tooMuch = DefPar.AddHHMembers.ParentCond + " ";
}
if (parPartner != null)
{
tooMuch = DefPar.AddHHMembers.PartnerCond;
}
if (parOther != null)
{
addInstruction.cond = parOther;
}
else
{
missing = DefPar.AddHHMembers.HHCond;
}
break;
default: continue; // error is caught by general error handling
}
if (missing != string.Empty)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{description.Get()} (group {groupNo}): {DefPar.AddHHMembers.Add_Who}={addInstruction.addWho} requires parameter {missing}"
});
}
if (tooMuch != string.Empty)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = true,
message = $"{description.Get()} (group {groupNo}): {DefPar.AddHHMembers.Add_Who}={addInstruction.addWho} does not require {tooMuch}"
});
}
// here we are only gathering the variables that are to be set, but do not evaluate whether they exist
// note: this function does not "register" variables, i.e. if a variable is not used anywhere else, it cannot be set
foreach (ParFormula parVarDefinition in GetPlaceholderGroupPar <ParFormula>(group))
{
string varName = parVarDefinition.description.GetParName();
if (addInstruction.prepVarDefinitions.ContainsKey(varName))
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{parVarDefinition.description.Get()}: double definition of variable {varName}"
});
continue;
}
if (varName == DefVarName.IDHH || varName == DefVarName.IDPERSON || varName == DefVarName.DWT || varName == DefVarName.DCT)
{
infoStore.communicator.ReportError(new Communicator.ErrorInfo()
{
isWarning = false,
message = $"{parVarDefinition.description.Get()}: variable {varName} is system-set and cannot be changed"
});
continue;
}
addInstruction.prepVarDefinitions.Add(varName, parVarDefinition);
}
addInstructions.Add(addInstruction);
}
}