Esempio n. 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="subSet"></param>
        /// <param name="Definition"></param>
        /// <returns></returns>
        private bool bDiffers(TParameterSet subSet, TParameterDefinition Definition)
        {
            bool result;

            if (!Definition.bValueDefined())
            {
                result = false;
            }
            else if ((subSet.Parent == null) || (!subSet.Parent.bIsDefined(Definition.sFullName)))
            {
                result = true;
            }
            else
            {
                switch (Definition.paramType)
                {
                case ptyReal: result = (subSet.fParam(Definition.sFullName) != subSet.Parent.fParam(Definition.sFullName));
                    break;

                case ptyInt: result = (subSet.iParam(Definition.sFullName) != subSet.Parent.iParam(Definition.sFullName));
                    break;

                case ptyBool: result = (subSet.bParam(Definition.sFullName) != subSet.Parent.bParam(Definition.sFullName));
                    break;

                case ptyText: result = (subSet.sParam(Definition.sFullName) != subSet.Parent.sParam(Definition.sFullName));
                    break;

                default: result = false;
                    break;
                }
            }
            return(result);
        }
Esempio n. 2
0
        private void writeParameters(TParameterSet subSet, TParameterDefinition Definition, List <string> Strings, int iIndent)
        {
            int    iDiffCount;
            string sLine;
            int    Idx;

            if (Definition.iDimension() > 1)                                         // Multi-dimensional array of
            {
                for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)                   //   parameters - recurse
                {
                    writeParameters(subSet, Definition.item(Idx), Strings, iIndent);
                }
            }

            else if (Definition.bIsScalar() && bDiffers(subSet, Definition))      // Single parameter value
            {
                sLine = new string(' ', iIndent)
                        + "<par name=\"" + Definition.sFullName + "\">"
                        + subSet.sParam(Definition.sFullName)
                        + "</par>";
                Strings.Add(sLine);
            }
            else                                                                 // List of parameter values (one-
            {                                                                    //   dimensional)
                iDiffCount = 0;
                for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)
                {
                    if (bDiffers(subSet, Definition.item(Idx)))
                    {
                        iDiffCount++;
                    }
                }

                if (iDiffCount > 1)                                                // More than one difference - write
                {                                                                  //   the differing values in a list
                    sLine = new string(' ', iIndent)
                            + "<par name=\"" + Definition.sFullName + "\">";
                    for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)
                    {
                        if (Idx > 0)
                        {
                            sLine += ',';
                        }
                        if (bDiffers(subSet, Definition.item(Idx)))
                        {
                            sLine += subSet.sParam(Definition.item(Idx).sFullName);
                        }
                    }
                    sLine += "</par>";
                    Strings.Add(sLine);
                }
                else if (iDiffCount == 1)                                           // Only one parameter is different -
                {
                    for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)              //  write it as a scalar
                    {
                        if (bDiffers(subSet, Definition.item(Idx)))
                        {
                            writeParameters(subSet, Definition.item(Idx), Strings, iIndent);
                        }
                    }
                }
            }
        }