public static string ParseMultiplicity(string identifier, NParsedAttributeValue parameters)
{
var parameter = ((NParsedAttributeAtomic)parameters).Value;
if (parameter is IdentifierExpression)
{
string value = ((IdentifierExpression)parameter).Value;
if (string.IsNullOrWhiteSpace(value))
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.INVALID_VALUE);
}
return(value);
}
if (parameter is StarExpression)
{
return("*");
}
if (parameter is ParsedInteger)
{
int value = ((ParsedInteger)parameter).Value;
if (value < 0)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.INVALID_VALUE);
}
return(value.ToString());
}
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.INVALID_VALUE);
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
if (!(v is ParsedBool))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.BOOL);
}
return(new DefaultValueAttribute()
{
Value = ((ParsedBool)((NParsedAttributeAtomic)value).Value).Value
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
if (!(v is ParsedString))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.STRING);
}
var stringValue = (ParsedString)v;
return(new ParsedCustomAttribute()
{
Key = identifier,
Value = stringValue.Value
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
if (!(v is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
return(new ParsedContextAttribute()
{
Value = ((NParsedAttributeAtomic)value).Value
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (value is NParsedAttributeColon)
{
var colonValue = ((NParsedAttributeColon)value);
var left = colonValue.Left;
var right = colonValue.Right;
if (!(left is IdentifierExpression) | !(right is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
var leftIdentifier = ((IdentifierExpression)left).Value;
return(new ParsedPredicateArgumentAttribute(leftIdentifier, right));
}
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.COLON_ONLY);
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
if (!(v is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
string multiplicity = "";
if (parameters != null)
{
if (parameters is NParsedAttributeAtomic)
{
multiplicity = ParseMultiplicity(identifier, parameters);
}
else if (parameters is NParsedAttributeList)
{
if (((NParsedAttributeList)parameters).Values.Count != 2)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.INVALID_VALUE);
}
var firstParameter = ((NParsedAttributeList)parameters).Values [0];
var secondParameter = ((NParsedAttributeList)parameters).Values [1];
string m1 = ParseMultiplicity(identifier, firstParameter);
string m2 = ParseMultiplicity(identifier, secondParameter);
multiplicity = m1 + ".." + m2;
}
else
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.ATOMIC_OR_LIST);
}
}
return(new ParsedLinkAttribute()
{
Target = ((NParsedAttributeAtomic)value).Value,
Multiplicity = multiplicity
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
if (!(v is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
var v2 = (IdentifierExpression)v;
switch (v2.Value)
{
case "software":
return(new ParsedAgentTypeAttribute()
{
Value = ParsedAgentType.Software
});
case "environment":
return(new ParsedAgentTypeAttribute()
{
Value = ParsedAgentType.Environment
});
case "malicious":
return(new ParsedAgentTypeAttribute()
{
Value = ParsedAgentType.Malicious
});
default:
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.INVALID_VALUE);
}
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
foreach (var parser in attributeParsers)
{
var regexString = @"^" + parser.GetIdentifier() + "$";
var regex = new Regex(regexString);
var match = regex.Match(identifier);
if (match.Success)
{
return(parser.ParsedAttribute(identifier, parameters, value));
}
}
throw new NotImplementedException("The attribute " + identifier + " is not valid for " + GetIdentifier() + ".");
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
double rds = 1;
if (v is ParsedFloat)
{
rds = ((ParsedFloat)v).Value;
}
else if (v is ParsedInteger)
{
rds = ((ParsedInteger)v).Value * 1d; // ntm: ignore 008b (Mul => Div)
}
else if (v is ParsedPercentage)
{
rds = ((ParsedPercentage)v).Value / 100;
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.FLOAT_INTEGER_PERCENTAGE_ONLY);
}
if (rds < 0 | rds > 1) // ntm: ignore 00de (Or => Xor)
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.PROBABILITY_EXPECTED);
}
return(new ParsedRDSAttribute()
{
Value = rds
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
string leftIdentifier = null;
dynamic type = null;
if (value is NParsedAttributeColon)
{
var colonValue = ((NParsedAttributeColon)value);
var left = colonValue.Left;
var right = colonValue.Right;
if (!(left is IdentifierExpression) | !(right is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
leftIdentifier = ((IdentifierExpression)left).Value;
type = right;
}
else if (value is NParsedAttributeAtomic)
{
var atomicValue = ((NParsedAttributeAtomic)value).Value;
if (atomicValue is IdentifierExpression)
{
leftIdentifier = ((IdentifierExpression)atomicValue).Value;
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_OR_COLON);
}
return(new ParsedAttributeAttribute(leftIdentifier, type));
}
public void TestNotAtomicValue(NParsedAttributeValue v)
{
var ap = new ResolvedByAttributeParser();
const string attIdentifier = "resolvedBy";
var e = Assert.Catch(() => {
ap.ParsedAttribute(attIdentifier,
null,
v);
});
Assert.IsInstanceOf(typeof(InvalidAttributeValueException), e);
StringAssert.AreEqualIgnoringCase(
string.Format(InvalidAttributeValueException.ATOMIC_ONLY, attIdentifier),
e.Message
);
}
public void TestNotColonParameter(NParsedAttributeValue v)
{
var ap = new ResolvedByAttributeParser();
const string attIdentifier = "resolvedBy";
var e = Assert.Catch(() => {
ap.ParsedAttribute(attIdentifier,
v,
new NParsedAttributeAtomic(new IdentifierExpression(attIdentifier)));
});
Assert.IsInstanceOf(typeof(InvalidParameterAttributeException), e);
StringAssert.AreEqualIgnoringCase(
string.Format(InvalidParameterAttributeException.COLON_ONLY, attIdentifier),
e.Message
);
}
public void TestNotColonValue(NParsedAttributeValue v)
{
var ap = new ArgumentAttributeParser();
const string attIdentifier = "argument";
var e = Assert.Catch(() => {
ap.ParsedAttribute(attIdentifier,
null,
v);
});
Assert.IsInstanceOf(typeof(InvalidAttributeValueException), e);
StringAssert.AreEqualIgnoringCase(
string.Format(InvalidAttributeValueException.COLON_ONLY, attIdentifier),
e.Message
);
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
return(new ParsedFormalSpecAttribute()
{
Value = ((NParsedAttributeAtomic)value).Value
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters == null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
if (!(parameters is NParsedAttributeAtomic))
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.ATOMIC_ONLY);
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var p = ((NParsedAttributeAtomic)parameters).Value;
var v = ((NParsedAttributeAtomic)value).Value;
if (!(p is IdentifierExpression))
{
throw new InvalidParameterAttributeException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
var pValue = (IdentifierExpression)p;
if (!(v is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
var stringValue = (IdentifierExpression)v;
return(new ParsedReplacesAttribute()
{
ObstacleIdentifier = pValue.Value,
ReplacedGoalIdentifier = stringValue.Value
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
string expert_id = null;
if (parameters != null)
{
if (parameters is NParsedAttributeAtomic)
{
var parameter = ((NParsedAttributeAtomic)parameters).Value;
if (parameter is IdentifierExpression)
{
expert_id = ((IdentifierExpression)parameter).Value;
}
else
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.IDENTIFIER);
}
}
else
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.ATOMIC_ONLY);
}
}
if (value is NParsedAttributeAtomic)
{
return(ParseAtomic(identifier, value, expert_id));
}
else if (value is NParsedAttributeBracket)
{
return(ParseBracket(identifier, value, expert_id));
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_OR_BRACKET);
}
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
if (parameters != null)
{
throw new NotImplementedException();
}
var parsedPredicates = new List <string>();
if (value is NParsedAttributeAtomic)
{
AddChild((NParsedAttributeAtomic)value, parsedPredicates);
}
else if (value is NParsedAttributeList)
{
foreach (var item in ((NParsedAttributeList)value).Values)
{
if (item is NParsedAttributeAtomic)
{
AddChild((NParsedAttributeAtomic)item, parsedPredicates);
}
else
{
throw new NotImplementedException("Attribute '" + identifier + "' only accept a list of identifiers. (Received: " +
string.Join(",", parsedPredicates.Select(x => x.GetType().ToString())) + ")");
}
}
}
else
{
throw new NotImplementedException("Attribute '" + identifier + "' only accept an atomic value or a list of atomic values.");
}
return(new ParsedMonitorsAttribute()
{
ParsedPredicates = parsedPredicates
});
}
private static ParsedElement ParseAtomic(string identifier, NParsedAttributeValue value, string expert_id)
{
var v = ((NParsedAttributeAtomic)value).Value;
double esr = -1;
if (v is ParsedFloat)
{
esr = ((ParsedFloat)v).Value;
}
else if (v is ParsedInteger)
{
esr = ((ParsedInteger)v).Value;
}
else if (v is ParsedDecimal)
{
esr = System.Convert.ToDouble(((ParsedDecimal)v).Value);
}
else if (v is ParsedPercentage)
{
esr = ((ParsedPercentage)v).Value / 100d;
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.FLOAT_INTEGER_PERCENTAGE_ONLY);
}
if (esr < 0 | esr > 1) // ntm: ignore 00de (Or => Xor)
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.PROBABILITY_EXPECTED);
}
return(new ParsedProbabilityAttribute()
{
Value = esr, ExpertIdentifier = expert_id
});
}
public ParsedElement ParsedAttribute(string identifier,
NParsedAttributeValue parameters,
NParsedAttributeValue value)
{
if (parameters != null)
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.NO_PARAM);
}
List <ParsedElement> v = new List <ParsedElement>();
if (value is NParsedAttributeAtomic)
{
AddValueToList(identifier, value, v);
}
else if (value is NParsedAttributeList)
{
var list = ((NParsedAttributeList)value);
foreach (var item in list.Values)
{
AddValueToList(identifier, item, v);
}
}
else
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_OR_LIST);
}
// TODO Remove casting and toList
return(new ParsedAssignedToAttribute()
{
Values = v.Cast <dynamic>().ToList()
});
}
private static ParsedElement ParseBracket(string identifier, NParsedAttributeValue value, string expert_id)
{
var item = ((NParsedAttributeBracket)value).Item;
var param = ((NParsedAttributeBracket)value).Parameter;
// Parse the name of the distribution
string distribution_name = ParseDistributionName(identifier, item);
// Parse the parameters of the distribution
List <double> distribution_parameters = ParseDistributionParameter(identifier, param);
// Build the parsed element
switch (distribution_name)
{
case "beta":
return(ParseBeta(identifier, distribution_parameters, expert_id));
case "uniform":
return(ParseUniform(identifier, distribution_parameters, expert_id));
case "triangular":
return(ParseTriangular(identifier, distribution_parameters, expert_id));
case "pert":
case "PERT":
return(ParsePERT(identifier, distribution_parameters, expert_id));
case "quantile":
case "quantiles":
return(ParseQuantile(identifier, distribution_parameters, expert_id));
default:
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.INVALID_VALUE);
}
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
ParsedResolutionPattern pattern = null;
string anchorId = null;
if (parameters != null)
{
if (parameters is NParsedAttributeColon)
{
var p = (NParsedAttributeColon)parameters;
var left = p.Left;
if (left is IdentifierExpression)
{
var patternId = ((IdentifierExpression)left).Value;
pattern = new ParsedResolutionPattern(patternId);
}
else
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.IDENTIFIER);
}
var right = p.Right;
if (right is IdentifierExpression)
{
anchorId = ((IdentifierExpression)right).Value;
}
else
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.IDENTIFIER);
}
}
else
{
throw new InvalidParameterAttributeException(identifier,
InvalidParameterAttributeException.COLON_ONLY);
}
}
if (!(value is NParsedAttributeAtomic))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.ATOMIC_ONLY);
}
var v = ((NParsedAttributeAtomic)value).Value;
if (!(v is IdentifierExpression))
{
throw new InvalidAttributeValueException(identifier,
InvalidAttributeValueException.IDENTIFIER);
}
return(new ParsedResolvedByAttribute()
{
Value = ((NParsedAttributeAtomic)value).Value,
Pattern = pattern,
AnchorId = anchorId
});
}
public ParsedElement ParsedAttribute(string identifier, NParsedAttributeValue parameters, NParsedAttributeValue value)
{
parsedRefinementPattern = null;
contextIdentifier = null;
if (parameters != null)
{
ParseParameter(identifier, parameters);
}
var parsedRefinees = new List <ParsedRefinee>();
if (value is NParsedAttributeAtomic)
{
AddChild((NParsedAttributeAtomic)value, parsedRefinees);
}
else if (value is NParsedAttributeList)
{
foreach (var item in ((NParsedAttributeList)value).Values)
{
if (item is NParsedAttributeAtomic)
{
AddChild((NParsedAttributeAtomic)item, parsedRefinees);
}
else if (item is NParsedAttributeBracket)
{
var child = ((NParsedAttributeBracket)item).Item;
var parameters_child = ((NParsedAttributeBracket)item).Parameter;
var refinee = new ParsedRefinee();
if (child is IdentifierExpression)
{
refinee.Identifier = ((IdentifierExpression)child).Value;
}
else
{
throw new NotImplementedException();
}
// TODO fix this
if (parameters_child is NParsedAttributeAtomic)
{
var parameter_child = ((NParsedAttributeAtomic)parameters_child).Value;
if (parameter_child is ParsedFloat)
{
refinee.Parameters = new ParsedPrimitiveRefineeParameter <double>(((ParsedFloat)parameter_child).Value);
}
else if (parameter_child is ParsedInteger)
{
refinee.Parameters = new ParsedPrimitiveRefineeParameter <double>(((ParsedInteger)parameter_child).Value);
}
else
{
throw new NotImplementedException(parameter_child.GetType().ToString() + " " + parameter_child.ToString());
}
}
else
{
throw new NotImplementedException();
}
parsedRefinees.Add(refinee);
}
else
{
throw new NotImplementedException("Attribute '" + identifier + "' only accept a list of identifiers. (Received: " +
string.Join(",", parsedRefinees.Select(x => x.GetType().ToString())) + ")");
}
}
}
else
{
throw new NotImplementedException("Attribute '" + identifier + "' only accept an atomic value or a list of atomic values.");
}
// TODO Remove casting and toList
return(new ParsedRefinedByAttribute()
{
ParsedRefinees = parsedRefinees,
RefinementPattern = parsedRefinementPattern,
ContextIdentifier = contextIdentifier,
});
}
