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);
}
public MiniShell(DuneApplication da, string xmlPath, string baseDirMini, string constraint,
bool methodWildcard, bool templateWildcard, string miniLocation)
{
this.da = da;
this.xmlPath = xmlPath;
this.baseDirMini = baseDirMini;
this.constraint = constraint;
this.methodWildcard = methodWildcard;
this.templateWildcard = templateWildcard;
this.miniLocation = miniLocation;
}
public static String generateMiniFileContent(DuneApplication da)
{
StringBuilder miniContent = new StringBuilder();
StringBuilder varPointDefinitions = new StringBuilder();
foreach (KeyValuePair <String, VariationPoint> varP in da.varPoints)
{
generateVariationPointContent(varP.Value, varP.Value.getIdentifyer(), miniContent, varPointDefinitions);
}
miniContent.Append(varPointDefinitions);
return(miniContent.ToString());
}
public static String generateFilteredMiniFileContent(DuneApplication da)
{
foreach (KeyValuePair <string, VariationPoint> vaPo in da.varPoints)
{
Dictionary <string, DuneFeature> alternatives = new Dictionary <string, DuneFeature>();
foreach (KeyValuePair <string, DuneFeature> alt in vaPo.Value.alternatives)
{
if (!alt.Key.Contains("??"))
{
alternatives.Add(alt.Key, alt.Value);
}
}
vaPo.Value.alternatives = alternatives;
}
return(generateMiniFileContent(da));
}
private static void writeAlternativesForVariationPoints(DuneApplication da, string RESULT_DIR)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("XML File " + Program.XML_PATH);
sb.AppendLine("MAIN_FILE_DUNE_APPLICATION " + Program.BASE_DIR_DUNE_APPLICATION + Program.MAIN_FILE_DUNE_APPLICATION);
foreach (KeyValuePair <string, VariationPoint> varPoint in da.varPoints)
{
List <String> result = varPoint.Value.alternatives.Keys.ToList();
sb.AppendLine("original value " + varPoint.Value.defaultValue);
foreach (String s in result)
{
sb.AppendLine(s);
}
sb.AppendLine("-----------------------");
}
StreamWriter sw = File.CreateText(Program.RESULT_DIR + "result.txt");
sw.Write(sb.ToString());
sw.Flush();
sw.Close();
}
/// <summary>
/// The main-method of the Dune-plugin. This calls the corresponding <code>XMLParser</code>-methods.
/// </summary>
static void Main(string[] args)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
// If the path is not given as argument, use the path specified in this file.
if (args.Length > 0)
{
if (args.Length == 1 && args[0].EndsWith(".txt"))
{
parseConfigFile(args[0]);
if (Directory.Exists(BASE_DIR_DUNE_APPLICATION_MINI_VERSION))
{
Directory.Delete(BASE_DIR_DUNE_APPLICATION_MINI_VERSION, true);
}
copyDuneApplicationToMiniLocation(BASE_DIR_DUNE_APPLICATION, BASE_DIR_DUNE_APPLICATION_MINI_VERSION);
DuneApplication da = new DuneApplication(XML_PATH, BASE_DIR_DUNE_APPLICATION_MINI_VERSION, CONSTRAINT_FILE
, REPLACE_UNKNOWN_CLASSES_METHOD_WILDCARD, REPLACE_UNKNOWN_CLASSES_TEMPLATE_WILDCARD);
// TODO Flag in starter file
if (USE_INTERACTIVE_SHELL)
{
MiniShell shell = new MiniShell(da, XML_PATH, BASE_DIR_DUNE_APPLICATION_MINI_VERSION, CONSTRAINT_FILE,
REPLACE_UNKNOWN_CLASSES_METHOD_WILDCARD, REPLACE_UNKNOWN_CLASSES_TEMPLATE_WILDCARD, MINI_FILE_LOCATION);
shell.run();
}
else
{
writeAlternativesForVariationPoints(da, RESULT_DIR);
generateVariants(da, RESULT_DIR);
}
Environment.Exit(-1);
}
else
{
XML_PATH = args[0];
if (args.Length == 1)
{
DEBUG_PATH = args[1];
// Add an additional directory separator if it was not included by the user.
DEBUG_PATH = DEBUG_PATH.EndsWith(Path.DirectorySeparatorChar.ToString()) ? DEBUG_PATH : DEBUG_PATH + Path.DirectorySeparatorChar;
}
infoLogger = new DuneAnalyzationLogger(DEBUG_PATH + "analyzation.log");
String duneStructure = "";
String mainFileCaseStudy = "";
String constraintFile = "";
if (args.Length > 2)
{
duneStructure = args[1];
mainFileCaseStudy = args[2];
if (args.Length > 3)
{
constraintFile = args[3];
}
DuneApplication da = new DuneApplication(duneStructure, mainFileCaseStudy, constraintFile);
}
}
}
else
{
System.Console.WriteLine("No path passed as argument. Aborting...");
printUsage();
Environment.Exit(-1);
}
XMLParser.parse(XML_PATH);
Shell.showShell();
System.Console.WriteLine("Press a button to close the window.");
System.Console.ReadKey();
}
private static void generateVariants(DuneApplication da, string RESULT_DIR)
{
int numberOfVariants = 1;
// identify all alternatives without ??
String unfilteredMiniFileContent = ProgramUtil.generateMiniFileContent(da);
File.WriteAllText(RESULT_DIR + "unfilteredmini.mini", unfilteredMiniFileContent);
foreach (KeyValuePair <String, VariationPoint> varP in da.varPoints)
{
Dictionary <String, DuneFeature> resultsUnfiltered = ProgramUtil.getAlternativesRecursive(varP.Value.defaultValue);
Dictionary <String, DuneFeature> filtered = ProgramUtil.filter(resultsUnfiltered);
varP.Value.alternatives = filtered;
numberOfVariants = numberOfVariants * filtered.Count;
}
//List<Variant> allVariants = new List<Variant>();
//for(int i = 0; i < numberOfVariants; i++)
//{
// allVariants.Add(new Variant());
//}
Dictionary <VariationPoint, int> varPo = new Dictionary <VariationPoint, int>();
foreach (KeyValuePair <String, VariationPoint> varP in da.varPoints)
{
varPo.Add(varP.Value, varP.Value.alternatives.Count);
}
List <KeyValuePair <VariationPoint, int> > varPList = varPo.ToList();
double[,] allAlternatives = getFullFactorial(varPList, numberOfVariants);
for (int i = 0; i < allAlternatives.GetLength(0); i++)
{
String curr = "";
for (int j = 0; j < allAlternatives.GetLength(1); j++)
{
curr = curr + allAlternatives.GetValue(new int[] { i, j }) + ";";
}
File.AppendAllText(RESULT_DIR + "variants2.txt", curr + Environment.NewLine);
}
//for (int i = 0; i < allVariants.Count; i++)
//{
// int varPIndex = 0;
// foreach (KeyValuePair<VariationPoint,int> varP in varPList)
// {
// int alternative = (int)allAlternatives[i, varPIndex];
// string value = varP.Key.alternatives[alternative];
// allVariants[i].selectedAlternatives.Add(varP.Key, value);
// varPIndex++;
// }
//}
//foreach (KeyValuePair<String, VariationPoint> varP in da.varPoints)
//{
// int repitions = allVariants.Count / powerTwo;
// int currIndex = 0;
// for (int i = 0; i < allVariants.Count; i++)
// {
// for(int repi = 0; repi < repitions; repitions++)
// {
// Variant variant = allVariants[i + repi];
// variant.selectedAlternatives.Add(varP.Value, varP.Value.alternatives[currIndex]);
// //variant.selectedAlternatives.Add(varP.Value, ""+currIndex);
// }
// currIndex = ((currIndex +1) % varP.Value.alternatives.Count);
// }
// powerTwo = powerTwo * 2;
//}
//Console.WriteLine( allVariants.Count);
String miniFileContent = ProgramUtil.generateMiniFileContent(da);
File.WriteAllText(MINI_FILE_LOCATION, miniFileContent);
//writeVariantsToCSV(allVariants, Program.RESULT_DIR);
updateCMakeLists(NEW_C_MAKE_LISTS);
}
