public override bool Equals(System.Object obj)
{
// If parameter is null return false.
if (obj == null)
{
return(false);
}
// If parameter cannot be cast to DuneFeature return false.
DuneFeature p = obj as DuneFeature;
if ((System.Object)p == null)
{
return(false);
}
String ownRef = this.enumObject.getReference();
String objRef = p.getReference();
// If both objects have references then match them by reference
if (ownRef != null && !ownRef.Equals("") && objRef != null && !objRef.Equals(""))
{
return(ownRef.Equals(objRef));
}
// Return true if the fields match:
return((this.getFeatureName()).Equals(p.getFeatureName()));
}
/// <inheritdoc />
public override bool isApplicable(DuneFeature value)
{
if (value.GetType() != typeof(DuneClass) && value.GetType() != typeof(DuneVariable))
{
return(false);
}
// go over connection to indentify the innerClass/member variable with the constraint
foreach (String con in connection)
{
if (value.GetType() == typeof(DuneClass))
{
value = ((DuneClass)value).getInnerElement(con);
}
//else if (value.GetType() == typeof(DuneVariable))
// value = ((DuneVariable)value).getInnerElement(con);
if (value == null)
{
return(false);
}
}
DuneFeature targetFeature = ((DuneClass)value).getInnerElement(target);
if (targetFeature.GetType() == typeof(DuneVariable))
{
return(((DuneVariable)targetFeature).InitialValue.Value.Equals(this.valueToMatch));
}
return(false);
}
/// <summary>
/// Add the refering dune feature.
/// </summary>
/// <param name="df">the dune feature the current element refers to</param>
public void addInformation(DuneFeature df)
{
TemplateTree newPart = new TemplateTree(this);
List <DuneFeature> dfs = new List <DuneFeature>();
dfs.Add(df);
newPart.referseTo = dfs;
newPart.type = Kind.concrete;
newPart.artificalString = df.getFeatureNameWithoutTemplateAndNamespace();
newPart.isTerminal = true;
newPart.isNotParsable = df.isNotParsable;
newPart.parent = currElement;
currElement.children.Add(newPart);
lastElement = newPart;
}
/// <summary> /// Tests whether the provided DuneFeature object is valid for the constraint. /// </summary> /// <param name="value">The DuneFeature to validate.</param> /// <returns>TRUE if the DuneFeature is valid for the constraint, FALSE otherwise.</returns> public abstract bool isApplicable(DuneFeature value);
/// <inheritdoc />
public override bool isApplicable(DuneFeature value)
{
throw new NotImplementedException();
}
public static Dictionary <String, DuneFeature> getAlternativesRecursive(String input)
{
input = input.Trim();
bool inputHasTemplate = false;
List <String> alternatives = new List <string>();
DuneFeature importantClass = null;
TemplateTree treeOfInterest = new TemplateTree();
// split input in name and template parameters
String name = "";
String[] templateDefinedByUser = new String[0];
if (input.Contains('<'))
{
inputHasTemplate = true;
name = input.Substring(0, input.IndexOf('<')).Trim();
templateDefinedByUser = getTemplateParts(input);
}
else
{
name = input;
}
// Search for internal representations of the given class...
List <DuneClass> allOthers = new List <DuneClass>();
foreach (DuneClass others in XMLParser.featuresWithPublicMethods)
{
if (others.getFeatureNameWithoutTemplate().Equals(name))
{
importantClass = others;
allOthers.Add(others);
}
}
if (allOthers.Count > 1)
{
Program.infoLogger.log("Potential error in getAlternativesRecursive() in the identification of the DuneClass of the given class for " + input + ". ");
Program.infoLogger.logLine("More than one internal class could match the given one.");
importantClass = getDuneClassByNumberOfTemplateParameters(allOthers, templateDefinedByUser.Count());
}
// mapping from the default placeholder strings of the template in the strings of the given input template
Dictionary <String, String> mapping = new Dictionary <string, string>();
if (importantClass == null)
{
// input is the value of an enum
foreach (DuneEnum currEnum in XMLParser.enums)
{
foreach (String s in currEnum.getValues())
{
if (s.Equals(input))
{
importantClass = currEnum;
}
}
}
}
else
{
List <TemplateTree> templateOfClass = ((DuneClass)importantClass).templateElements;
String cont = "";
for (int i = 0; i < templateOfClass.Count; i++)
{
cont += templateOfClass[i].declmame_cont + " | ";
if (templateOfClass[i].declmame_cont.Trim().Length == 0)
{
if (mapping.ContainsKey(templateOfClass[i].deftype_cont))
{
mapping.Add(templateOfClass[i].deftype_cont + "_" + i, templateDefinedByUser[i]);
}
else
{
mapping.Add(templateOfClass[i].deftype_cont, templateDefinedByUser[i]);
}
}
else
{
if (mapping.ContainsKey(templateOfClass[i].declmame_cont))
{
mapping.Add(templateOfClass[i].declmame_cont + "_" + i, templateDefinedByUser[i]);
}
else
{
if (templateDefinedByUser.Count() - 1 < i)
{
if (templateOfClass[i].defaultValue == null)
{
mapping.Add(templateOfClass[i].declmame_cont, templateOfClass[i].defval_cont);
}
else
{
mapping.Add(templateOfClass[i].declmame_cont, templateOfClass[i].defaultValue.ToString());
}
}
else
{
mapping.Add(templateOfClass[i].declmame_cont, templateDefinedByUser[i]);
}
}
}
}
String s = cont;
}
if (importantClass == null)
{
Program.infoLogger.log("Potential error in getAlternativesRecursive() in the identification of the DuneClass of the given class for " + input + ". ");
Program.infoLogger.logLine("No internal representation for the given class could be found.");
return(new Dictionary <String, DuneFeature>());
//System.Environment.Exit(1);
}
Dictionary <String, DuneFeature> alternativesFirstLevel = ((DuneFeature)importantClass).getVariability();
Dictionary <String, DuneFeature> alternativesFirstLevelWithConcreteParameters = new Dictionary <String, DuneFeature>();
if (inputHasTemplate)
{
foreach (KeyValuePair <String, DuneFeature> element in alternativesFirstLevel)
{
if (((DuneClass)element.Value).templateElements.Count > 0)
{
DuneClass alternative = (DuneClass)element.Value;
String alternativStringWithUserInput = element.Value.getFeatureNameWithoutTemplate() + "<";
for (int i = 0; i < alternative.templateElements.Count; i++)
{
String nameTemplateParameter = alternative.templateElements[i].declmame_cont;
if (nameTemplateParameter.Trim().Length == 0)
{
if (mapping.ContainsKey(alternative.templateElements[i].deftype_cont))
{
alternativStringWithUserInput += mapping[alternative.templateElements[i].deftype_cont];
}
else
{
if (alternative.templateElements[i].deftype_cont.Length > 0)
{
if (alternative.templateElements[i].defval_cont.Length > 0)
{
if (mapping.ContainsKey(alternative.templateElements[i].defval_cont))
{
alternativStringWithUserInput += mapping[alternative.templateElements[i].defval_cont];
}
else
{
alternativStringWithUserInput += alternative.templateElements[i].defval_cont;
}
}
else
{
alternativStringWithUserInput += alternative.templateElements[i].deftype_cont;
}
}
else
{
String deftype_cont = alternative.templateElements[i].deftype_cont;
Double res;
if (Double.TryParse(deftype_cont, out res))
{
alternativStringWithUserInput += deftype_cont;
}
else
{
alternativStringWithUserInput += "??" + nameTemplateParameter + "??";
}
}
}
}
else
{
if (mapping.ContainsKey(nameTemplateParameter))
{
alternativStringWithUserInput += mapping[nameTemplateParameter];
}
else
{
if (alternative.templateElements[i].defval_cont.Length > 0)
{
alternativStringWithUserInput += alternative.templateElements[i].defval_cont;
}
else
{
alternativStringWithUserInput += "??" + nameTemplateParameter + "??";
}
}
}
if (i < alternative.templateElements.Count - 1)
{
alternativStringWithUserInput += ",";
}
else
{
alternativStringWithUserInput += ">";
}
}
if (!alternativesFirstLevelWithConcreteParameters.ContainsKey(alternativStringWithUserInput))
{
alternativesFirstLevelWithConcreteParameters.Add(alternativStringWithUserInput, element.Value);
}
}
else
{
alternativesFirstLevelWithConcreteParameters.Add(element.Key, element.Value);
}
}
}
else
{
foreach (KeyValuePair <String, DuneFeature> element in alternativesFirstLevel)
{
if (element.Value.GetType() == typeof(DuneEnum))
{
alternativesFirstLevelWithConcreteParameters.Add(element.Key, element.Value);
}
else
{
DuneClass alternative = (DuneClass)element.Value;
String alternativStringWithUserInput = alternative.getFeatureNameWithoutTemplate();
if (alternative.templateElements.Count > 0)
{
alternativStringWithUserInput += " < ";
for (int i = 0; i < alternative.templateElements.Count; i++)
{
String nameTemplateParameter = alternative.templateElements[i].declmame_cont;
if (mapping.ContainsKey(nameTemplateParameter))
{
alternativStringWithUserInput += mapping[nameTemplateParameter];
}
else
{
if (alternative.templateElements[i].defval_cont.Length > 0)
{
alternativStringWithUserInput += alternative.templateElements[i].defval_cont;
}
else
{
alternativStringWithUserInput += "??" + nameTemplateParameter + "??";
}
}
if (i < alternative.templateElements.Count - 1)
{
alternativStringWithUserInput += ",";
}
else
{
alternativStringWithUserInput += ">";
}
}
}
alternativesFirstLevelWithConcreteParameters.Add(alternativStringWithUserInput, element.Value);
}
}
}
return(alternativesFirstLevelWithConcreteParameters);
}
