public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
Match m;
if ((m = matcher.Match(spelling)).Success)
{
var ops = new List <ArithmeticCondition.Operation>();
foreach (Match op in operation.Matches(m.Groups["Ops"].Value))
{
ops.Add(new ArithmeticCondition.Operation
{
Number = double.Parse(op.Groups["Number"].Value, dialect.Parser.PatternCulture),
Operator = Arithmetic.GetArithmeticOperator(op.Groups["Op"].Value)
});
}
return(new ArithmeticCondition
{
Operations = ops,
CompareOperator = Arithmetic.GetCompareOperator(m.Groups["Op"].Value),
TargetValue = int.Parse(m.Groups["TargetValue"].Value)
});
}
return(null);
}
public IParameterEvaluator GetFor(ParameterSpec spec, PatternDialect dialect, TextManager manager)
{
if (spec.ParameterName.StartsWith("@"))
{
return(new PatternLookupEvaluator
{
Manager = manager,
PatternKey = spec.ParameterName.Substring(1),
Parameters = spec.Arguments != null?spec.Arguments.Split(',')
.Select(x =>
{
var parts = x.Trim().Split(':');
if (parts.Length > 1)
{
return new KeyValuePair <string, IValueFormatter>(parts[0], dialect.GetValueFormatter(parts[1], manager));
}
else
{
return new KeyValuePair <string, IValueFormatter>(parts[0], null);
}
}).ToArray() : new KeyValuePair <string, IValueFormatter> [0]
});
}
return(null);
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
Match m;
if ((m = matcher.Match(spelling)).Success)
{
var ops = new List<ArithmeticCondition.Operation>();
foreach (Match op in operation.Matches(m.Groups["Ops"].Value))
{
ops.Add(new ArithmeticCondition.Operation
{
Number = double.Parse(op.Groups["Number"].Value, dialect.Parser.PatternCulture),
Operator = Arithmetic.GetArithmeticOperator(op.Groups["Op"].Value)
});
}
return new ArithmeticCondition
{
Operations = ops,
CompareOperator = Arithmetic.GetCompareOperator(m.Groups["Op"].Value),
TargetValue = int.Parse(m.Groups["TargetValue"].Value)
};
}
return null;
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
Match m;
if ((m = intervalMatcher.Match(spelling)).Success)
{
return(CreateIntervalCondition(
m.Groups["Min"].Success ? m.Groups["Min"].Value : null,
m.Groups["Max"].Success ? m.Groups["Max"].Value : null,
m.Groups["MinInclusive"].Value == "[",
m.Groups["MaxInclusive"].Value == "]",
dialect.Parser.PatternCulture));
}
else if ((m = halfIntervalMatcher.Match(spelling)).Success)
{
return(CreateIntervalCondition(
m.Groups["Dir"].Value == ">" ? m.Groups["Limit"].Value : null,
m.Groups["Dir"].Value == "<" ? m.Groups["Limit"].Value : null,
m.Groups["Inclusive"].Success,
m.Groups["Inclusive"].Success,
dialect.Parser.PatternCulture));
}
return(null);
}
public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
{
if (!string.IsNullOrEmpty(formatExpression))
{
return(new StringFormatFormatter(formatExpression));
}
return(null);
}
public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
{
if (!string.IsNullOrEmpty(formatExpression))
{
return new StringFormatFormatter(formatExpression);
}
return null;
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
return(Key.GetHashCode() ^
PatternDialect.GetHashCode() ^
Pattern.GetHashCode() ^
Namespace.GetHashCode() ^
Language.GetHashCode());
}
public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
{
if (!string.IsNullOrEmpty(formatExpression) && formatExpression.Equals("roman", StringComparison.InvariantCulture))
{
return(new RomanNumberFormatter());
}
return(null);
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (string.IsNullOrEmpty(spelling) || spelling.Equals("true", StringComparison.InvariantCultureIgnoreCase))
{
return(new TakeAllCondition());
}
return(null);
}
public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
{
if (!string.IsNullOrEmpty(formatExpression) && formatExpression.Equals("roman", StringComparison.InvariantCulture))
{
return new RomanNumberFormatter();
}
return null;
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (string.IsNullOrEmpty(spelling) || spelling.Equals("true", StringComparison.InvariantCultureIgnoreCase))
{
return new TakeAllCondition();
}
return null;
}
public IParameterEvaluator GetFor(ParameterSpec spec, PatternDialect dialect, TextManager manager)
{
var parts = spec.ParameterName.Split('.');
if (parts.Length > 1)
{
return new ReflectionParameterEvaluator(parts[0], parts.Skip(1).ToArray());
}
return null;
}
public IParameterEvaluator GetFor(ParameterSpec spec, PatternDialect dialect, TextManager manager)
{
var parts = spec.ParameterName.Split('.');
if (parts.Length > 1)
{
return(new ReflectionParameterEvaluator(parts[0], parts.Skip(1).ToArray()));
}
return(null);
}
public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
{
StringCaseTransformationType type;
if (!string.IsNullOrEmpty(formatExpression)
&& _transformationTypes.TryGetValue(formatExpression.ToLowerInvariant(), out type))
{
return new StringCaseFormatter { TransformationType = type };
}
return null;
}
public IValueFormatter GetFor(string formatExpression, PatternDialect dialect, TextManager manager)
{
StringCaseTransformationType type;
if (!string.IsNullOrEmpty(formatExpression) &&
_transformationTypes.TryGetValue(formatExpression.ToLowerInvariant(), out type))
{
return(new StringCaseFormatter {
TransformationType = type
});
}
return(null);
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (spelling.StartsWith("@"))
{
var evaluator = dialect.GetParameterEvaluator(
new ParameterSpec { ParameterName = spelling }, manager) as PatternLookupEvaluator;
if (evaluator != null)
{
return new LookupCondition
{
Dialect = dialect,
Evaluator = evaluator
};
}
}
return null;
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (spelling.StartsWith("@"))
{
var evaluator = dialect.GetParameterEvaluator(
new ParameterSpec {
ParameterName = spelling
}, manager) as PatternLookupEvaluator;
if (evaluator != null)
{
return(new LookupCondition
{
Dialect = dialect,
Evaluator = evaluator
});
}
}
return(null);
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (!string.IsNullOrEmpty(spelling))
{
bool notEquals;
if (spelling.StartsWith("!="))
{
notEquals = true;
spelling = spelling.Substring(2).TrimStart();
}
else
{
notEquals = false;
if (spelling.StartsWith("="))
{
spelling = spelling.Substring(1).TrimStart();
}
}
var labels = spelling.Split(',').Select(x => x.Trim()).Where(x => x != "").ToArray();
//If all the labels can be converted to a number (i.e. a double) it's better to represent them as that instead of doing string conversions
bool allDouble = true;
double d;
double[] dvals = labels.Select(x => (allDouble = double.TryParse(x, out d)) ? d : 0).ToArray();
if (allDouble)
{
return(dvals.Length == 1 ? (ISwitchConditionEvaluator) new SingleValueCondition <double>(dvals[0], notEquals)
: new ValueListCondition <double>(dvals, notEquals));
}
else
{
return(dvals.Length == 1 ? (ISwitchConditionEvaluator) new SingleValueCondition <string>(labels[0], notEquals)
: new ValueListCondition <string>(labels, notEquals));
}
}
return(null);
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (spelling.StartsWith("(") && spelling.EndsWith(")"))
{
spelling = spelling.Substring(1, spelling.Length - 1);
}
Match m;
if ((m = _matcher.Match(spelling)).Success)
{
var left = RemoveParentheses(m.Groups["Left"].Value);
var right = RemoveParentheses(m.Groups["Right"].Value);
return new BooleanExpressionCondition
{
Left = dialect.GetSwitchConditionEvaluator(Expression.Text(left), manager),
Disjunction = m.Groups["Operator"].Value.Equals("or", StringComparison.CurrentCultureIgnoreCase),
Right = dialect.GetSwitchConditionEvaluator(Expression.Text(right), manager)
};
}
return null;
}
public override ISwitchConditionEvaluator GetFor(string spelling, PatternDialect dialect, TextManager manager)
{
if (spelling.StartsWith("(") && spelling.EndsWith(")"))
{
spelling = spelling.Substring(1, spelling.Length - 1);
}
Match m;
if ((m = _matcher.Match(spelling)).Success)
{
var left = RemoveParentheses(m.Groups["Left"].Value);
var right = RemoveParentheses(m.Groups["Right"].Value);
return(new BooleanExpressionCondition
{
Left = dialect.GetSwitchConditionEvaluator(Expression.Text(left), manager),
Disjunction = m.Groups["Operator"].Value.Equals("or", StringComparison.CurrentCultureIgnoreCase),
Right = dialect.GetSwitchConditionEvaluator(Expression.Text(right), manager)
});
}
return(null);
}
public IValueFormatter GetFor(string rep, PatternDialect dialect, TextManager manager)
{
return(new DefaultFormatter());
}
public IValueFormatter GetFor(string rep, PatternDialect dialect, TextManager manager)
{
return new DefaultFormatter();
}
public IParameterEvaluator GetFor(ParameterSpec spelling, PatternDialect dialect, TextManager manager)
{
return new SimpleParameterEvaluator(spelling.ParameterName);
}
/// <summary>
/// Override this method to use the build in pattern decorator
/// </summary>
public virtual void Decorate(PatternDialect dialect, TextManager manager)
{
}
public override void Decorate(PatternDialect dialect, TextManager manager)
{
DecoratedText = "Decorated: " + Text;
}
public IParameterEvaluator GetFor(ParameterSpec spelling, PatternDialect dialect, TextManager manager)
{
return(new SimpleParameterEvaluator(spelling.ParameterName));
}
public IParameterEvaluator GetFor(ParameterSpec spec, PatternDialect dialect, TextManager manager)
{
if( spec.ParameterName.StartsWith("@") )
{
return new PatternLookupEvaluator
{
Manager = manager,
PatternKey = spec.ParameterName.Substring(1),
Parameters = spec.Arguments != null ? spec.Arguments.Split(',')
.Select(x =>
{
var parts = x.Trim().Split(':');
if (parts.Length > 1)
{
return new KeyValuePair<string, IValueFormatter>(parts[0], dialect.GetValueFormatter(parts[1], manager));
}
else
{
return new KeyValuePair<string, IValueFormatter>(parts[0], null);
}
}).ToArray() : new KeyValuePair<string, IValueFormatter>[0]
};
}
return null;
}
