Example #1
0
        private void applyConstraints(Dictionary <string, VariationPoint> varPoints, List <Constraint> constraints)
        {
            foreach (Constraint c in constraints)
            {
                if (c.GetType() == typeof(SimpleConstraint))
                {
                    Dictionary <String, DuneFeature> validAlternative = new Dictionary <string, DuneFeature>();

                    VariationPoint relevantVarPoint = varPoints[c.matchingVarPoint];
                    if (relevantVarPoint != null)
                    {
                        foreach (KeyValuePair <String, DuneFeature> alternative in relevantVarPoint.alternatives)
                        {
                            if (c.isApplicable(alternative.Value))
                            {
                                validAlternative.Add(alternative.Key, alternative.Value);
                            }
                        }
                    }
                    relevantVarPoint.alternatives = validAlternative;
                }
                else if (c.GetType() == typeof(ComplexConstraint))
                {
                }
            }
        }
        private bool tryGetVariationPoint(string name, DuneApplication da, out VariationPoint vaPo)
        {
            bool succeded = da.varPoints.TryGetValue(name, out vaPo);

            if (!succeded)
            {
                writeConsoleWarning("Error: Invalid VariationPoint(VariationPoint names are case sensitive).");
            }
            return(succeded);
        }
Example #3
0
        private Dictionary <String, VariationPoint> parseApplicationMainClass(string mainFileCaseStudy)
        {
            Dictionary <String, VariationPoint> varPoints = new Dictionary <String, VariationPoint>();

            StringBuilder newContent = new StringBuilder();

            try
            {
                string[] readText = File.ReadAllLines(mainFileCaseStudy);

                bool           nextLineIsDefaultFeature = false;
                VariationPoint lastVarPoint             = null;

                for (int i = 0; i < readText.Length; i++)
                {
                    String line = readText[i];

                    if (nextLineIsDefaultFeature)
                    {
                        line = line.Replace(lastVarPoint.defaultValue, lastVarPoint.getIdentifyer());

                        newContent.AppendLine(line);

                        nextLineIsDefaultFeature = false;
                    }
                    else
                    {
                        newContent.AppendLine(line);
                    }

                    if (line.Contains(VariationPoint.VARIATIONPOINTCONSTANT))
                    {
                        string relevantPart = line.Split(new String[] { VariationPoint.VARIATIONPOINTCONSTANT }, StringSplitOptions.RemoveEmptyEntries)[1].Trim();
                        relevantPart = relevantPart.Substring(1, relevantPart.Length - 2).Trim();

                        Program.infoLogger.log("variant point: " + relevantPart);

                        VariationPoint varPoint = new VariationPoint(relevantPart, i);
                        varPoints.Add(varPoint.Name, varPoint);
                        nextLineIsDefaultFeature = true;
                        lastVarPoint             = varPoint;
                    }
                    File.WriteAllText(mainFileCaseStudy, newContent.ToString());
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }

            return(varPoints);
        }
Example #4
0
        public static void generateVariationPointContent(VariationPoint vaPo, string identifyer,
                                                         StringBuilder miniContent, StringBuilder varPointDefinitions)
        {
            StringBuilder alternatives = new StringBuilder();

            varPointDefinitions.Append(identifyer + " = ");

            alternativesToString(vaPo.alternatives, identifyer, alternatives, varPointDefinitions);

            varPointDefinitions = varPointDefinitions.Remove(varPointDefinitions.ToString().Length - 2, 2);
            varPointDefinitions.AppendLine(" | expand");

            miniContent.Append(alternatives);
        }