/// <summary>
/// Convenient factory method to parse input pattern, build capturing expression and instantiate
/// binding template instance.
/// </summary>
/// <param name="input">A binding template string in a format supported by <see cref="BindingTemplateParser"/>.
/// </param>
/// <returns>Valid ready-to-use instance of <see cref="BindingTemplateSource"/>.</returns>
public static BindingTemplateSource FromString(string input)
{
IEnumerable <BindingTemplateToken> tokens = BindingTemplateParser.GetTokens(input);
string capturePattern = BuildCapturePattern(tokens);
return(new BindingTemplateSource(input, new Regex(capturePattern, RegexOptions.Compiled)));
}
/// <summary>
/// Factory method that constructs a <see cref="BindingTemplateSource"/> from an input binding template pattern.
/// </summary>
/// <remarks>
/// A template string may contain parameters embraced with curly brackets, which get replaced
/// with values later when the template is bound.
/// </remarks>
/// <example>
/// Below is a minimal template that illustrates a few basics:
/// {p1}-p2/{{2014}}/folder/{name}.{ext}
/// </example>
/// <param name="pattern">A binding template pattern string in a supported format (see remarks).
/// </param>
/// <param name="ignoreCase">True if matches should be case insensitive.</param>
/// <returns>An instance of <see cref="BindingTemplateSource"/> for the specified template pattern.</returns>
public static BindingTemplateSource FromString(string pattern, bool ignoreCase = false)
{
IEnumerable <BindingTemplateToken> tokens = BindingTemplateParser.GetTokens(pattern);
string capturePattern = BindingTemplateToken.BuildCapturePattern(tokens);
RegexOptions options = RegexOptions.Compiled;
if (ignoreCase)
{
options |= RegexOptions.IgnoreCase;
}
return(new BindingTemplateSource(pattern, new Regex(capturePattern, options)));
}
public static BindingTemplateToken NewExpression(string expression)
{
// BindingData takes precedence over builtins.
BindingParameterResolver builtin;
BindingParameterResolver.TryGetResolver(expression, out builtin);
// check for formatter, which is applied to finale results.
string format = null;
if (builtin == null)
{
int indexColon = expression.IndexOf(':');
if (indexColon > 0)
{
format = expression.Substring(indexColon + 1);
expression = expression.Substring(0, indexColon);
}
}
if (!BindingTemplateParser.IsValidIdentifier(expression))
{
throw new FormatException($"Invalid template expression '{expression}");
}
// Expression is just a series of dot operators like: a.b.c
var parts = expression.Split('.');
// For backwards compat, first part can't have a '-'
if (builtin == null)
{
if (parts[0].IndexOf('-') >= 0)
{
throw new FormatException($"The parameter name '{parts[0]}' is invalid.");
}
}
foreach (var part in parts)
{
if (string.IsNullOrWhiteSpace(part))
{
throw new InvalidOperationException($"Illegal expression: {parts}");
}
}
return(new ExpressionToken(parts, format, builtin));
}
/// <summary>
/// A factory method to parse input template string and construct a binding template instance using
/// parsed tokens sequence.
/// </summary>
/// <param name="input">A binding template string in a format supported by <see cref="BindingTemplateParser"/>.
/// </param>
/// <param name="ignoreCase">True if matching should be case insensitive.</param>
/// <returns>Valid ready-to-use instance of <see cref="BindingTemplate"/>.</returns>
public static BindingTemplate FromString(string input, bool ignoreCase = false)
{
IReadOnlyList <BindingTemplateToken> tokens = BindingTemplateParser.ParseTemplate(input);
return(new BindingTemplate(input, tokens, ignoreCase));
}
/// <summary>
/// A factory method to parse input template string and construct a binding template instance using
/// parsed tokens sequence.
/// </summary>
/// <param name="input">A binding template string in a format supported by <see cref="BindingTemplateParser"/>.
/// </param>
/// <returns>Valid ready-to-use instance of <see cref="BindingTemplate"/>.</returns>
public static BindingTemplate FromString(string input)
{
IReadOnlyList <BindingTemplateToken> tokens = BindingTemplateParser.ParseTemplate(input);
return(new BindingTemplate(input, tokens));
}
