/// <summary>
/// Creates forbidden parameter combinations.
/// </summary>
/// <param name="forbiddenParameterClauses">
/// Matches from <see cref="ForbiddenParameterClausePattern"/>.
/// </param>
/// <param name="parameterDefinitions">All parameter definitions.</param>
/// <returns>The created <see cref="ForbiddenParameterCombination"/>s.</returns>
private static IEnumerable <ForbiddenParameterCombination> CreateForbiddenParameterCombinations(
IEnumerable <Match> forbiddenParameterClauses,
List <IParameterNode> parameterDefinitions)
{
return(forbiddenParameterClauses
.Select(clause => ParameterConfigurationSpaceConverter.CreateForbiddenParameterClause(clause, parameterDefinitions)));
}
/// <summary>
/// Creates a mapping from parameter identifiers to conditions determining whether they are active.
/// </summary>
/// <param name="conditionalParameterClauses">
/// Matches from <see cref="ConditionalParameterClausePattern"/>.
/// </param>
/// <param name="parameterDefinitions">All parameter definitions.</param>
/// <returns>The created mapping.</returns>
private static Dictionary <string, List <EqualsCondition> > CreateParameterActivityConditions(
IEnumerable <Match> conditionalParameterClauses,
List <IParameterNode> parameterDefinitions)
{
var parameterActivityConditions = new Dictionary <string, List <EqualsCondition> >();
foreach (var clause in conditionalParameterClauses)
{
var childIdentifier = clause.Groups[ParameterConfigurationSpaceConverter.ChildGroupName].Value;
if (!parameterDefinitions.Any(definition => Equals(definition.Identifier, childIdentifier)))
{
throw new InvalidOperationException(
$"Tried to create a condition for '{childIdentifier}', which was not defined.");
}
if (!parameterActivityConditions.TryGetValue(childIdentifier, out var conditions))
{
conditions = new List <EqualsCondition>();
parameterActivityConditions.Add(childIdentifier, conditions);
}
conditions.Add(ParameterConfigurationSpaceConverter.CreateCondition(clause, parameterDefinitions));
}
return(parameterActivityConditions);
}
/// <summary>
/// Converts a PCS file into a <see cref="ParameterConfigurationSpaceSpecification"/>.
/// </summary>
/// <param name="path">Path to the file.</param>
/// <returns>The created <see cref="ParameterConfigurationSpaceSpecification"/>.</returns>
public static ParameterConfigurationSpaceSpecification Convert(string path)
{
if (!File.Exists(path))
{
throw new FileNotFoundException($"No file at {path}.");
}
var parameters = new List <IParameterNode>();
var conditionalParameterClauses = new List <Match>();
var forbiddenParameterClauses = new List <Match>();
foreach (var line in File.ReadAllLines(path))
{
if (line.StartsWith("#") || string.IsNullOrEmpty(line))
{
// Comment or blank line.
continue;
}
var match = ParameterConfigurationSpaceConverter.ConditionalParameterClausePattern.Match(line);
if (match.Success)
{
// Delay parsing of conditional clauses until all parameters are known.
conditionalParameterClauses.Add(match);
continue;
}
match = ParameterConfigurationSpaceConverter.ForbiddenParameterClausePattern.Match(line);
if (match.Success)
{
// Delay parsing of forbidden parameter clauses until all parameters are known.
forbiddenParameterClauses.Add(match);
continue;
}
match = ParameterConfigurationSpaceConverter.CategoricalParameterClausePattern.Match(line);
if (match.Success)
{
parameters.Add(ParameterConfigurationSpaceConverter.CreateCategoricalParameter(match));
continue;
}
match = ParameterConfigurationSpaceConverter.NumericalParameterClausePattern.Match(line);
if (match.Success)
{
parameters.Add(ParameterConfigurationSpaceConverter.CreateNumericalParameter(match));
continue;
}
throw new FormatException($"Cannot parse '{line}'. Is the format correct?");
}
return(new ParameterConfigurationSpaceSpecification(
parameters,
ParameterConfigurationSpaceConverter.CreateParameterActivityConditions(conditionalParameterClauses, parameters),
ParameterConfigurationSpaceConverter.CreateForbiddenParameterCombinations(forbiddenParameterClauses, parameters)));
}
/// <summary>
/// Creates a <see cref="EqualsCondition"/>.
/// </summary>
/// <param name="conditionalParameterClause">
/// A match from <see cref="ConditionalParameterClausePattern"/>.
/// </param>
/// <param name="parameterDefinitions">All parameter definitions.</param>
/// <returns>The created <see cref="EqualsCondition"/>.</returns>
private static EqualsCondition CreateCondition(
Match conditionalParameterClause,
List <IParameterNode> parameterDefinitions)
{
var parentIdentifier = conditionalParameterClause.Groups[ParameterConfigurationSpaceConverter.ParentGroupName].Value;
var domain = ParameterConfigurationSpaceConverter.FindParameterDomain(parameterDefinitions, parentIdentifier);
var valueSpecifications = conditionalParameterClause.Groups[ParameterConfigurationSpaceConverter.ValueGroupName].Value
.Split(',')
.Select(value => value.Trim());
return(new EqualsCondition(
parentIdentifier,
valueSpecifications.Select(value => ParameterConfigurationSpaceConverter.TransformValueToAllele(domain, value))));
}
/// <summary>
/// Creates a numerical parameter.
/// </summary>
/// <param name="numericalParameterClause">A match from <see cref="NumericalParameterClausePattern"/>.</param>
/// <returns>The created <see cref="IParameterNode"/>.</returns>
private static IParameterNode CreateNumericalParameter(Match numericalParameterClause)
{
var identifier = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.ParameterGroupName].Value;
var minValue = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.MinValueGroupName].Value;
var maxValue = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.MaxValueGroupName].Value;
var isLogarithmic = numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.LogScaleGroupName].Success ||
numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.AlternativeLogScaleGroupName].Success;
if (numericalParameterClause.Groups[ParameterConfigurationSpaceConverter.IntegerGroupName].Success)
{
return(ParameterConfigurationSpaceConverter.CreateIntegerParameter(identifier, minValue, maxValue, isLogarithmic));
}
else
{
return(ParameterConfigurationSpaceConverter.CreateContinuousParameter(identifier, minValue, maxValue, isLogarithmic));
}
}
/// <summary>
/// Creates a <see cref="ForbiddenParameterCombination"/>.
/// </summary>
/// <param name="forbiddenParameterClause">
/// A match from <see cref="ForbiddenParameterClausePattern"/>.
/// </param>
/// <param name="parameterDefinitions">All parameter definitions.</param>
/// <returns>The created <see cref="ForbiddenParameterCombination"/>.</returns>
private static ForbiddenParameterCombination CreateForbiddenParameterClause(
Match forbiddenParameterClause,
List <IParameterNode> parameterDefinitions)
{
var completeSpecification = forbiddenParameterClause.Groups[ParameterConfigurationSpaceConverter.CombinationGroupName].Value;
var assignmentMatches = ParameterConfigurationSpaceConverter.AssignmentPattern.Matches(completeSpecification);
var forbiddenCombination = new Dictionary <string, IAllele>();
foreach (Match match in assignmentMatches)
{
var identifier = match.Groups[ParameterConfigurationSpaceConverter.ParameterGroupName].Value;
var value = match.Groups[ParameterConfigurationSpaceConverter.ValueGroupName].Value;
var domain = ParameterConfigurationSpaceConverter.FindParameterDomain(parameterDefinitions, identifier);
forbiddenCombination[identifier] = ParameterConfigurationSpaceConverter.TransformValueToAllele(domain, value);
}
return(new ForbiddenParameterCombination(forbiddenCombination));
}
