예제 #1
0
        // used by HasMinValInTU and HasMaxValInTU
        protected void PrepareMinMaxPar(FunBase fun, List <string> footnoteNumbers)
        {
            minMaxVal = fun.GetFootnotePar <ParVarIL>(DefQuery.Par.Val, footnoteNumbers);
            if (minMaxVal == null)
            {
                infoStore.communicator.ReportError(new Communicator.ErrorInfo()
                {
                    isWarning = false, message = $"{description.Get()}: compulsory query-parameter {DefQuery.Par.Val} missing"
                });
            }

            ParBool parUnique = fun.GetFootnotePar <ParBool>(DefQuery.Par.Unique, footnoteNumbers);

            if (parUnique != null)
            {
                minMaxUnique = parUnique.GetBoolValue();
            }

            ParBool parAd = fun.GetFootnotePar <ParBool>(DefQuery.Par.Adults_Only, footnoteNumbers);

            if (parAd != null)
            {
                minMaxAdultsOnly = parAd.GetBoolValue();
            }
        }
예제 #2
0
 protected override void PrepareNonCommonPar()
 {
     parShare         = GetUniquePar <ParFormula>(DefPar.Allocate.Share);
     parShareBetween  = GetUniquePar <ParCond>(DefPar.Allocate.Share_Between);
     parShareProp     = GetUniquePar <ParVarIL>(DefPar.Allocate.Share_Prop);
     shareAllIfNoElig = GetParBoolValueOrDefault(DefFun.Allocate, DefPar.Allocate.Share_All_IfNoElig);
     shareEquIfZero   = GetParBoolValueOrDefault(DefFun.Allocate, DefPar.Allocate.Share_Equ_IfZero);
     ignoreNegProp    = GetParBoolValueOrDefault(DefFun.Allocate, DefPar.Allocate.Ignore_Neg_Prop);
 }
예제 #3
0
        private void AddToOutList(string outName, Description description)
        {
            if (outList.ContainsKey(outName))
            {
                return;                               // already in, avoid "double-printing"
            }
            ParVarIL parOut = new ParVarIL(infoStore)
            {
                xmlValue = outName, description = description
            };

            parOut.CheckAndPrepare(this); // note that ParVarIL.CheckAndPrepare a.o. takes care of setting isGlobal, isTULevel
            outList.Add(outName, parOut);
        }
예제 #4
0
 protected void PrepareIncomeInfoPar(FunBase fun, List <string> footnoteNumbers) // ... ditto income/info parameter
 {
     parIncome = fun.GetFootnotePar <ParVarIL>(DefQuery.Par.Income, footnoteNumbers);
     if (parIncome == null)
     {
         parIncome = fun.GetFootnotePar <ParVarIL>(DefQuery.Par.Info, footnoteNumbers);
     }
     if (parIncome == null)
     {
         infoStore.communicator.ReportError(new Communicator.ErrorInfo()
         {
             isWarning = false, message = $"{description.Get()}: compulsory query-parameter {DefQuery.Par.Income} missing"
         });
     }
 }
예제 #5
0
        /// <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()
        {
            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();
        }