Exemple #1
0
        private bool print_csv(List <Configuration> configurations, List <NFProperty> nfpPropertiesToPrint)
        {
            StringBuilder csvContent = new StringBuilder();

            for (int i = 0; i < this.order.Count; i++)
            {
                ConfigurationOption c = this.order[i];
                if (i != 0)
                {
                    csvContent.Append(CSV_ELEMENT_DELIMITER);
                }
                csvContent.Append(c.Name);
            }

            if (!GlobalState.currentNFP.Equals(NFProperty.DefaultProperty))
            {
                foreach (NFProperty nfpProperty in nfpPropertiesToPrint)
                {
                    csvContent.Append(CSV_ELEMENT_DELIMITER);
                    csvContent.Append(nfpProperty.Name);
                }
            }

            csvContent.Append(CSV_ROW_DELIMITER);

            foreach (Configuration c in configurations)
            {
                csvContent.Append(c.toCsv(this.order, nfpPropertiesToPrint));
            }

            File.WriteAllText(file, csvContent.ToString());

            return(true);
        }
        /// <summary>
        /// Adds a configuration option to the variability model.
        /// The method checks whether an option with the same name already exists and whether invalid characters are within the name
        /// </summary>
        /// <param name="option">The option to be added to the variability model.</param>
        /// <returns>True if the option was added to the model, false otherwise</returns>
        public bool addConfigurationOption(ConfigurationOption option)
        {
            if (option.Name.Contains('-') || option.Name.Contains('+'))
            {
                return(false);
            }

            // the vitrual root configuration option does not have to be added to the variability model.
            if (option.Name.Equals("root"))
            {
                return(true);
            }

            foreach (var opt in binaryOptions)
            {
                if (opt.Name.Equals(option.Name))
                {
                    return(false);
                }
            }
            foreach (var opt in numericOptions)
            {
                if (opt.Name.Equals(option.Name))
                {
                    return(false);
                }
            }

            if (this.hasOption(option.ParentName))
            {
                option.Parent = this.getOption(option.ParentName);
            }


            //Every option must have a parent
            if (option.Parent == null)
            {
                option.Parent = this.root;
            }

            if (option is BinaryOption)
            {
                this.binaryOptions.Add((BinaryOption)option);
            }
            else
            {
                this.numericOptions.Add((NumericOption)option);
            }

            // create Index
            optionToIndex.Add(optionToIndex.Count, option);
            indexToOption.Add(option, indexToOption.Count);


            return(true);
        }
        /// <summary>
        /// Removes a configuration from the variability model.
        /// </summary>
        /// <param name="toDelete"></param>
        public void deleteOption(ConfigurationOption toDelete)
        {
            // Removing all children
            List <ConfigurationOption> children = new List <ConfigurationOption>();

            foreach (ConfigurationOption opt in this.BinaryOptions)
            {
                if (opt.Parent != null && opt.Parent.Equals(toDelete))
                {
                    children.Add(opt);
                }
            }

            foreach (ConfigurationOption child in children)
            {
                deleteOption(child);
            }

            // Removing option from other options
            foreach (ConfigurationOption opt in getOptions())
            {
                for (int i = opt.Excluded_Options.Count - 1; i >= 0; i--)
                {
                    if (opt.Excluded_Options[i].Contains(toDelete))
                    {
                        opt.Excluded_Options.RemoveAt(i);
                    }
                }

                for (int i = opt.Implied_Options.Count - 1; i >= 0; i--)
                {
                    if (opt.Implied_Options[i].Contains(toDelete))
                    {
                        opt.Implied_Options.RemoveAt(i);
                    }
                }
            }

            // Removing option from constraints
            binaryConstraints.RemoveAll(x => x.Contains(toDelete.ToString()));
            nonBooleanConstraints.RemoveAll(x => x.ToString().Contains(toDelete.ToString()));

            if (toDelete is BinaryOption)
            {
                binaryOptions.Remove((BinaryOption)toDelete);
            }
            else if (toDelete is NumericOption)
            {
                numericOptions.Remove((NumericOption)toDelete);
            }
            else
            {
                throw new Exception("An illegal option was found while deleting.");
            }
        }
 /// <summary>
 /// Searches for a numeric option with the given name.
 /// </summary>
 /// <param name="name">Name of the option</param>
 /// <returns>Either the numeric option with the given name or NULL if not found</returns>
 public NumericOption getNumericOption(String name)
 {
     name = ConfigurationOption.removeInvalidCharsFromName(name);
     foreach (var numO in numericOptions)
     {
         if (numO.Name.Equals(name))
         {
             return(numO);
         }
     }
     return(null);
 }
 /// <summary>
 /// Searches for a binary option with the given name.
 /// </summary>
 /// <param name="name">Name of the option</param>
 /// <returns>Either the binary option with the given name or NULL if not found</returns>
 public BinaryOption getBinaryOption(String name)
 {
     name = ConfigurationOption.removeInvalidCharsFromName(name);
     foreach (var binO in binaryOptions)
     {
         if (binO.Name.Equals(name))
         {
             return(binO);
         }
     }
     return(null);
 }
        /// <summary>
        /// Returns whether the influence function coints a specific configuration option.
        /// </summary>
        /// <param name="option"></param>
        /// <returns></returns>
        public bool containsOption(ConfigurationOption option)
        {
            if (this.participatingBoolOptions.Contains(option))
            {
                return(true);
            }

            if (this.participatingNumOptions.Contains(option))
            {
                return(true);
            }
            return(false);
        }
        /// <summary>
        /// This method retuns the configuration with the given name.
        /// </summary>
        /// <param name="name">Name of the option under consideration.</param>
        /// <returns>The option with the given name or NULL of no option with the name is defined.</returns>
        public ConfigurationOption getOption(String name)
        {
            name = ConfigurationOption.removeInvalidCharsFromName(name);
            ConfigurationOption opt = getNumericOption(name);

            if (opt != null)
            {
                return(opt);
            }
            opt = getBinaryOption(name);

            return(opt);
        }
Exemple #8
0
        /// <summary>
        /// Returns the csv-representation of the configuration.
        /// </summary>
        /// <returns>The csv-representation of the configuration.</returns>
        /// <param name="order">The order of the configuration options.</param>
        public string toCsv(List <ConfigurationOption> order, List <NFProperty> nfpProperties)
        {
            StringBuilder result = new StringBuilder();

            for (int i = 0; i < order.Count; i++)
            {
                ConfigurationOption c = order[i];

                if (i != 0)
                {
                    result.Append(ConfigurationPrinter.CSV_ELEMENT_DELIMITER);
                }

                if (c.GetType().Equals(typeof(BinaryOption)))
                {
                    if (this.BinaryOptions.ContainsKey((BinaryOption)c) &&
                        this.BinaryOptions[(BinaryOption)c] == BinaryOption.BinaryValue.Selected)
                    {
                        result.Append(1);
                    }
                    else
                    {
                        result.Append(0);
                    }
                }
                else
                {
                    NumericOption n = (NumericOption)c;
                    if (this.numericOptions.ContainsKey(n))
                    {
                        result.Append(this.NumericOptions[n]);
                    }
                }
            }

            if (nfpProperties != null && nfpProperties.Count != 0 && !GlobalState.currentNFP.Equals(NFProperty.DefaultProperty))
            {
                result.Append(ConfigurationPrinter.CSV_ELEMENT_DELIMITER);
                foreach (NFProperty nfp in this.nfpValues.Keys)
                {
                    if (nfpProperties.Contains(nfp))
                    {
                        result.Append(this.nfpValues[nfp]);
                        result.Append(ConfigurationPrinter.CSV_ELEMENT_DELIMITER);
                    }
                }
                result.Remove(result.Length - ConfigurationPrinter.CSV_ELEMENT_DELIMITER.Length, ConfigurationPrinter.CSV_ELEMENT_DELIMITER.Length);
            }
            result.Append(ConfigurationPrinter.CSV_ROW_DELIMITER);
            return(result.ToString());
        }
        /// <summary>
        /// Returns the csv-representation of the configuration.
        /// </summary>
        /// <returns>The csv-representation of the configuration.</returns>
        /// <param name="order">The order of the configuration options.</param>
        public string toCsv(List <ConfigurationOption> order)
        {
            StringBuilder result = new StringBuilder();

            for (int i = 0; i < order.Count; i++)
            {
                ConfigurationOption c = order[i];

                if (i != 0)
                {
                    result.Append(ConfigurationPrinter.CSV_ELEMENT_DELIMITER);
                }

                if (c.GetType().Equals(typeof(BinaryOption)))
                {
                    if (this.BinaryOptions.ContainsKey((BinaryOption)c))
                    {
                        result.Append(1);
                    }
                    else
                    {
                        result.Append(0);
                    }
                }
                else
                {
                    NumericOption n = (NumericOption)c;
                    if (this.numericOptions.ContainsKey(n))
                    {
                        result.Append(this.NumericOptions[n]);
                    }
                }
            }

            if (!GlobalState.currentNFP.Equals(NFProperty.DefaultProperty))
            {
                result.Append(ConfigurationPrinter.CSV_ELEMENT_DELIMITER);
                if (this.nfpValues.ContainsKey(GlobalState.currentNFP))
                {
                    result.Append(this.nfpValues[GlobalState.currentNFP]);
                }
                else
                {
                    result.Append(Double.NaN);
                }
            }
            result.Append(ConfigurationPrinter.CSV_ROW_DELIMITER);
            return(result.ToString());
        }
        /// <summary>
        /// This method reads all configurations specified in the .csv file. In this mehtod, we assume that the file has a header.
        /// </summary>
        /// <param name="file"></param>
        /// <param name="model">The variabiliy model for the configurations.</param>
        /// <returns>A list of all configurations </returns>
        public static List <Configuration> readConfigurations_Header_CSV(String file, VariabilityModel model)
        {
            List <Configuration> configurations = new List <Configuration>();

            StreamReader sr = new StreamReader(file);

            String[] optionOrder = new String[model.getOptions().Count];
            String[] nfpOrder    = null;

            bool isHeader = true;

            while (!sr.EndOfStream)
            {
                String[] tokens = sr.ReadLine().Split(';');

                if (isHeader)
                {
                    nfpOrder = new String[tokens.Length - optionOrder.Length];
                    for (int i = 0; i < tokens.Length; i++)
                    {
                        String token = tokens[i];
                        if (i < optionOrder.Length)
                        {
                            optionOrder[i] = token;
                        }
                        else
                        {
                            nfpOrder[i - optionOrder.Length] = token;
                            if (!GlobalState.nfProperties.ContainsKey(token))
                            {
                                GlobalState.nfProperties.Add(token, new NFProperty(token));
                            }
                        }
                    }
                    isHeader = false;
                }
                else
                {
                    Dictionary <BinaryOption, BinaryOption.BinaryValue> binOptions = new Dictionary <BinaryOption, BinaryOption.BinaryValue>();
                    Dictionary <NumericOption, double> numOptions = new Dictionary <NumericOption, double>();
                    Dictionary <NFProperty, double>    properties = new Dictionary <NFProperty, double>();

                    for (int i = 0; i < tokens.Length; i++)
                    {
                        String token = tokens[i];
                        if (i < optionOrder.Length)
                        {
                            ConfigurationOption option = model.getOption(optionOrder[i]);
                            if (option.GetType() == typeof(BinaryOption))
                            {
                                if (token.Equals("true") || token.Equals("1"))
                                {
                                    binOptions.Add((BinaryOption)option, BinaryOption.BinaryValue.Selected);
                                }
                            }
                            else
                            {
                                double value = Convert.ToDouble(token);
                                numOptions.Add((NumericOption)option, value);
                            }
                        }
                        else
                        {
                            NFProperty nfp   = GlobalState.nfProperties[nfpOrder[i - optionOrder.Length]];
                            double     value = Convert.ToDouble(token);
                            properties.Add(nfp, value);

                            double currentMaxMeasuredValue;
                            if (GlobalState.allMeasurements.maxMeasuredValue.TryGetValue(nfp, out currentMaxMeasuredValue))
                            {
                                if (Math.Abs(value) > Math.Abs(currentMaxMeasuredValue))
                                {
                                    GlobalState.allMeasurements.maxMeasuredValue[nfp] = value;
                                }
                            }
                            else
                            {
                                GlobalState.allMeasurements.maxMeasuredValue.Add(nfp, value);
                            }
                        }
                    }

                    Configuration config = new Configuration(binOptions, numOptions, properties);
                    configurations.Add(config);
                }
            }
            sr.Close();
            return(configurations);
        }