/// <summary> /// Constructs a new <see cref="TemplatePart"/> instance given a <paramref name="other"/>. /// </summary> /// <param name="other">A <see cref="RoutePatternPart"/> instance representing the route part.</param> public TemplatePart(RoutePatternPart other) { IsLiteral = other.IsLiteral || other.IsSeparator; IsParameter = other.IsParameter; if (other.IsLiteral && other is RoutePatternLiteralPart literal) { Text = literal.Content; } else if (other.IsParameter && other is RoutePatternParameterPart parameter) { // Text is unused by TemplatePart and assumed to be null when the part is a parameter. Name = parameter.Name; IsCatchAll = parameter.IsCatchAll; IsOptional = parameter.IsOptional; DefaultValue = parameter.Default; InlineConstraints = parameter.ParameterPolicies?.Select(p => new InlineConstraint(p)) ?? Enumerable.Empty <InlineConstraint>(); } else if (other.IsSeparator && other is RoutePatternSeparatorPart separator) { Text = separator.Content; IsOptionalSeperator = true; } else { // Unreachable throw new NotSupportedException(); } }
private static string BuildRoutePart(RoutePatternPart part) { return(part switch { RoutePatternLiteralPart lit => lit.Content, RoutePatternParameterPart param => $"{{{param.Name}}}", RoutePatternSeparatorPart sep => sep.Content, _ => string.Empty });
static string ToString(RoutePatternPart part) { if (part is RoutePatternLiteralPart literal) { return($"Literal: {literal.Content}"); } if (part is RoutePatternSeparatorPart separator) { return($"Separator: {separator.Content}"); } else { var parameter = (RoutePatternParameterPart)part; return($"Parameter: Name = {parameter.Name}; Default = {parameter.Default}; IsOptional = { parameter.IsOptional}; IsCatchAll = { parameter.IsCatchAll}; ParameterKind = { parameter.ParameterKind}"); } }
private string GetRoutePatternPartPropertyValue(RoutePatternPart part, out bool isOptional) { var value = string.Empty; if (part is RoutePatternLiteralPart literalPart) { value = literalPart.Content; } else if (part is RoutePatternParameterPart parameterPart) { value = parameterPart.Name; } bool.TryParse(part.GetType().GetProperty("IsOptional")?.GetValue(part).ToString(), out isOptional); return(value); }
private static void WriteString(StringBuilder sb, RoutePatternPart part) { if (part.IsParameter && part is RoutePatternParameterPart parameterPart) { sb.Append('{'); if (parameterPart.IsCatchAll) { sb.Append('*'); if (!parameterPart.EncodeSlashes) { sb.Append('*'); } } sb.Append(parameterPart.Name); foreach (var item in parameterPart.ParameterPolicies) { sb.Append(':'); sb.Append(item.Content); } if (parameterPart.Default != null) { sb.Append('='); sb.Append(parameterPart.Default); } if (parameterPart.IsOptional) { sb.Append('?'); } sb.Append('}'); } else if (part is RoutePatternLiteralPart literalPart) { sb.Append(literalPart.Content); } else if (part is RoutePatternSeparatorPart separatorPart) { sb.Append(separatorPart.Content); } else { throw new NotSupportedException(); } }
/// <summary> /// Converts the <see cref="RouteTemplate"/> to the equivalent /// <see cref="RoutePattern"/> /// </summary> /// <returns>A <see cref="RoutePattern"/>.</returns> public Other ToRoutePattern() { var builder = RoutePatternBuilder.Create(TemplateText); for (var i = 0; i < Segments.Count; i++) { var segment = Segments[i]; var parts = new List <RoutePatternPart>(); for (var j = 0; j < segment.Parts.Count; j++) { var part = segment.Parts[j]; if (part.IsLiteral && part.IsOptionalSeperator) { parts.Add(RoutePatternPart.CreateSeparator(part.Text)); } else if (part.IsLiteral) { parts.Add(RoutePatternPart.CreateLiteral(part.Text)); } else { var kind = part.IsCatchAll ? RoutePatternParameterKind.CatchAll : part.IsOptional ? RoutePatternParameterKind.Optional : RoutePatternParameterKind.Standard; var constraints = part.InlineConstraints.Select(c => ConstraintReference.Create(c.Constraint)).ToArray(); parts.Add(RoutePatternPart.CreateParameter(part.Name, part.DefaultValue, kind, constraints)); } } builder.AddPathSegment(parts.ToArray()); } return(builder.Build()); }
private bool Equals(RoutePatternPart x, RoutePatternPart y) { if (x.GetType() != y.GetType()) { return(false); } if (x.IsLiteral && y.IsLiteral) { return(Equals((RoutePatternLiteralPart)x, (RoutePatternLiteralPart)y)); } else if (x.IsParameter && y.IsParameter) { return(Equals((RoutePatternParameterPart)x, (RoutePatternParameterPart)y)); } else if (x.IsSeparator && y.IsSeparator) { return(Equals((RoutePatternSeparatorPart)x, (RoutePatternSeparatorPart)y)); } Debug.Fail("This should not be reachable. Do you need to update the comparison logic?"); return(false); }