mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
673 lines
32 KiB
C#
673 lines
32 KiB
C#
namespace System.Web.Routing {
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
internal sealed class ParsedRoute {
|
|
public ParsedRoute(IList<PathSegment> pathSegments) {
|
|
Debug.Assert(pathSegments != null);
|
|
|
|
PathSegments = pathSegments;
|
|
}
|
|
|
|
private IList<PathSegment> PathSegments {
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public BoundUrl Bind(RouteValueDictionary currentValues, RouteValueDictionary values, RouteValueDictionary defaultValues, RouteValueDictionary constraints) {
|
|
if (currentValues == null) {
|
|
currentValues = new RouteValueDictionary();
|
|
}
|
|
if (values == null) {
|
|
values = new RouteValueDictionary();
|
|
}
|
|
if (defaultValues == null) {
|
|
defaultValues = new RouteValueDictionary();
|
|
}
|
|
|
|
|
|
// The set of values we should be using when generating the URL in this route
|
|
RouteValueDictionary acceptedValues = new RouteValueDictionary();
|
|
|
|
// Keep track of which new values have been used
|
|
HashSet<string> unusedNewValues = new HashSet<string>(values.Keys, StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
|
// Step 1: Get the list of values we're going to try to use to match and generate this URL
|
|
|
|
|
|
// Find out which entries in the URL are valid for the URL we want to generate.
|
|
// If the URL had ordered parameters a="1", b="2", c="3" and the new values
|
|
// specified that b="9", then we need to invalidate everything after it. The new
|
|
// values should then be a="1", b="9", c=<no value>.
|
|
ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
|
|
// If it's a parameter subsegment, examine the current value to see if it matches the new value
|
|
string parameterName = parameterSubsegment.ParameterName;
|
|
|
|
object newParameterValue;
|
|
bool hasNewParameterValue = values.TryGetValue(parameterName, out newParameterValue);
|
|
if (hasNewParameterValue) {
|
|
unusedNewValues.Remove(parameterName);
|
|
}
|
|
|
|
object currentParameterValue;
|
|
bool hasCurrentParameterValue = currentValues.TryGetValue(parameterName, out currentParameterValue);
|
|
|
|
if (hasNewParameterValue && hasCurrentParameterValue) {
|
|
if (!RoutePartsEqual(currentParameterValue, newParameterValue)) {
|
|
// Stop copying current values when we find one that doesn't match
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If the parameter is a match, add it to the list of values we will use for URL generation
|
|
if (hasNewParameterValue) {
|
|
if (IsRoutePartNonEmpty(newParameterValue)) {
|
|
acceptedValues.Add(parameterName, newParameterValue);
|
|
}
|
|
}
|
|
else {
|
|
if (hasCurrentParameterValue) {
|
|
acceptedValues.Add(parameterName, currentParameterValue);
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
// Add all remaining new values to the list of values we will use for URL generation
|
|
foreach (var newValue in values) {
|
|
if (IsRoutePartNonEmpty(newValue.Value)) {
|
|
if (!acceptedValues.ContainsKey(newValue.Key)) {
|
|
acceptedValues.Add(newValue.Key, newValue.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add all current values that aren't in the URL at all
|
|
foreach (var currentValue in currentValues) {
|
|
string parameterName = currentValue.Key;
|
|
if (!acceptedValues.ContainsKey(parameterName)) {
|
|
ParameterSubsegment parameterSubsegment = GetParameterSubsegment(PathSegments, parameterName);
|
|
if (parameterSubsegment == null) {
|
|
acceptedValues.Add(parameterName, currentValue.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add all remaining default values from the route to the list of values we will use for URL generation
|
|
ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
|
|
if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName)) {
|
|
object defaultValue;
|
|
if (!IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue)) {
|
|
// Add the default value only if there isn't already a new value for it and
|
|
// only if it actually has a default value, which we determine based on whether
|
|
// the parameter value is required.
|
|
acceptedValues.Add(parameterSubsegment.ParameterName, defaultValue);
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
|
|
// All required parameters in this URL must have values from somewhere (i.e. the accepted values)
|
|
bool hasAllRequiredValues = ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
|
|
object defaultValue;
|
|
if (IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue)) {
|
|
if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName)) {
|
|
// If the route parameter value is required that means there's
|
|
// no default value, so if there wasn't a new value for it
|
|
// either, this route won't match.
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
if (!hasAllRequiredValues) {
|
|
return null;
|
|
}
|
|
|
|
// All other default values must match if they are explicitly defined in the new values
|
|
RouteValueDictionary otherDefaultValues = new RouteValueDictionary(defaultValues);
|
|
ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) {
|
|
otherDefaultValues.Remove(parameterSubsegment.ParameterName);
|
|
return true;
|
|
});
|
|
|
|
foreach (var defaultValue in otherDefaultValues) {
|
|
object value;
|
|
if (values.TryGetValue(defaultValue.Key, out value)) {
|
|
unusedNewValues.Remove(defaultValue.Key);
|
|
if (!RoutePartsEqual(value, defaultValue.Value)) {
|
|
// If there is a non-parameterized value in the route and there is a
|
|
// new value for it and it doesn't match, this route won't match.
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Step 2: If the route is a match generate the appropriate URL
|
|
|
|
StringBuilder url = new StringBuilder();
|
|
StringBuilder pendingParts = new StringBuilder();
|
|
|
|
bool pendingPartsAreAllSafe = false;
|
|
bool blockAllUrlAppends = false;
|
|
|
|
for (int i = 0; i < PathSegments.Count; i++) {
|
|
PathSegment pathSegment = PathSegments[i]; // parsedRouteUrlPart
|
|
|
|
if (pathSegment is SeparatorPathSegment) {
|
|
if (pendingPartsAreAllSafe) {
|
|
// Accept
|
|
if (pendingParts.Length > 0) {
|
|
if (blockAllUrlAppends) {
|
|
return null;
|
|
}
|
|
|
|
// Append any pending literals to the URL
|
|
url.Append(pendingParts.ToString());
|
|
pendingParts.Length = 0;
|
|
}
|
|
}
|
|
pendingPartsAreAllSafe = false;
|
|
|
|
// Guard against appending multiple separators for empty segements
|
|
if (pendingParts.Length > 0 && pendingParts[pendingParts.Length - 1] == '/') {
|
|
// Dev10 676725: Route should not be matched if that causes mismatched tokens
|
|
// Dev11 86819: We will allow empty matches if all subsequent segments are null
|
|
if (blockAllUrlAppends) {
|
|
return null;
|
|
}
|
|
|
|
// Append any pending literals to the URL(without the trailing slash) and prevent any future appends
|
|
url.Append(pendingParts.ToString(0, pendingParts.Length - 1));
|
|
pendingParts.Length = 0;
|
|
blockAllUrlAppends = true;
|
|
}
|
|
else {
|
|
pendingParts.Append("/");
|
|
}
|
|
}
|
|
else {
|
|
ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
|
|
if (contentPathSegment != null) {
|
|
// Segments are treated as all-or-none. We should never output a partial segment.
|
|
// If we add any subsegment of this segment to the generated URL, we have to add
|
|
// the complete match. For example, if the subsegment is "{p1}-{p2}.xml" and we
|
|
// used a value for {p1}, we have to output the entire segment up to the next "/".
|
|
// Otherwise we could end up with the partial segment "v1" instead of the entire
|
|
// segment "v1-v2.xml".
|
|
bool addedAnySubsegments = false;
|
|
|
|
foreach (PathSubsegment subsegment in contentPathSegment.Subsegments) {
|
|
LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment;
|
|
if (literalSubsegment != null) {
|
|
// If it's a literal we hold on to it until we are sure we need to add it
|
|
pendingPartsAreAllSafe = true;
|
|
pendingParts.Append(UrlEncode(literalSubsegment.Literal));
|
|
}
|
|
else {
|
|
ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment;
|
|
if (parameterSubsegment != null) {
|
|
if (pendingPartsAreAllSafe) {
|
|
// Accept
|
|
if (pendingParts.Length > 0) {
|
|
if (blockAllUrlAppends) {
|
|
return null;
|
|
}
|
|
|
|
// Append any pending literals to the URL
|
|
url.Append(pendingParts.ToString());
|
|
pendingParts.Length = 0;
|
|
|
|
addedAnySubsegments = true;
|
|
}
|
|
}
|
|
pendingPartsAreAllSafe = false;
|
|
|
|
// If it's a parameter, get its value
|
|
object acceptedParameterValue;
|
|
bool hasAcceptedParameterValue = acceptedValues.TryGetValue(parameterSubsegment.ParameterName, out acceptedParameterValue);
|
|
if (hasAcceptedParameterValue) {
|
|
unusedNewValues.Remove(parameterSubsegment.ParameterName);
|
|
}
|
|
|
|
object defaultParameterValue;
|
|
defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultParameterValue);
|
|
|
|
if (RoutePartsEqual(acceptedParameterValue, defaultParameterValue)) {
|
|
// If the accepted value is the same as the default value, mark it as pending since
|
|
// we won't necessarily add it to the URL we generate.
|
|
pendingParts.Append(UrlEncode(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture)));
|
|
}
|
|
else {
|
|
if (blockAllUrlAppends) {
|
|
return null;
|
|
}
|
|
|
|
// Add the new part to the URL as well as any pending parts
|
|
if (pendingParts.Length > 0) {
|
|
// Append any pending literals to the URL
|
|
url.Append(pendingParts.ToString());
|
|
pendingParts.Length = 0;
|
|
}
|
|
url.Append(UrlEncode(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture)));
|
|
|
|
addedAnySubsegments = true;
|
|
}
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path subsegment type");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (addedAnySubsegments) {
|
|
// See comment above about why we add the pending parts
|
|
if (pendingParts.Length > 0) {
|
|
if (blockAllUrlAppends) {
|
|
return null;
|
|
}
|
|
|
|
// Append any pending literals to the URL
|
|
url.Append(pendingParts.ToString());
|
|
pendingParts.Length = 0;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path segment type");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pendingPartsAreAllSafe) {
|
|
// Accept
|
|
if (pendingParts.Length > 0) {
|
|
if (blockAllUrlAppends) {
|
|
return null;
|
|
}
|
|
|
|
// Append any pending literals to the URL
|
|
url.Append(pendingParts.ToString());
|
|
}
|
|
}
|
|
|
|
// Process constraints keys
|
|
if (constraints != null) {
|
|
// If there are any constraints, mark all the keys as being used so that we don't
|
|
// generate query string items for custom constraints that don't appear as parameters
|
|
// in the URL format.
|
|
foreach (var constraintsItem in constraints) {
|
|
unusedNewValues.Remove(constraintsItem.Key);
|
|
}
|
|
}
|
|
|
|
|
|
// Add remaining new values as query string parameters to the URL
|
|
if (unusedNewValues.Count > 0) {
|
|
// Generate the query string
|
|
bool firstParam = true;
|
|
foreach (string unusedNewValue in unusedNewValues) {
|
|
object value;
|
|
if (acceptedValues.TryGetValue(unusedNewValue, out value)) {
|
|
url.Append(firstParam ? '?' : '&');
|
|
firstParam = false;
|
|
url.Append(Uri.EscapeDataString(unusedNewValue));
|
|
url.Append('=');
|
|
url.Append(Uri.EscapeDataString(Convert.ToString(value, CultureInfo.InvariantCulture)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return new BoundUrl {
|
|
Url = url.ToString(),
|
|
Values = acceptedValues
|
|
};
|
|
}
|
|
|
|
private static string EscapeReservedCharacters(Match m) {
|
|
return "%" + Convert.ToUInt16(m.Value[0]).ToString("x2", CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
private static bool ForEachParameter(IList<PathSegment> pathSegments, Func<ParameterSubsegment, bool> action) {
|
|
for (int i = 0; i < pathSegments.Count; i++) {
|
|
PathSegment pathSegment = pathSegments[i];
|
|
|
|
if (pathSegment is SeparatorPathSegment) {
|
|
// We only care about parameter subsegments, so skip this
|
|
continue;
|
|
}
|
|
else {
|
|
ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
|
|
if (contentPathSegment != null) {
|
|
foreach (PathSubsegment subsegment in contentPathSegment.Subsegments) {
|
|
LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment;
|
|
if (literalSubsegment != null) {
|
|
// We only care about parameter subsegments, so skip this
|
|
continue;
|
|
}
|
|
else {
|
|
ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment;
|
|
if (parameterSubsegment != null) {
|
|
if (!action(parameterSubsegment)) {
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path subsegment type");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path segment type");
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static ParameterSubsegment GetParameterSubsegment(IList<PathSegment> pathSegments, string parameterName) {
|
|
ParameterSubsegment foundParameterSubsegment = null;
|
|
|
|
bool continueProcessing = ForEachParameter(pathSegments, delegate(ParameterSubsegment parameterSubsegment) {
|
|
if (String.Equals(parameterName, parameterSubsegment.ParameterName, StringComparison.OrdinalIgnoreCase)) {
|
|
foundParameterSubsegment = parameterSubsegment;
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
return foundParameterSubsegment;
|
|
}
|
|
|
|
private static bool IsParameterRequired(ParameterSubsegment parameterSubsegment, RouteValueDictionary defaultValues, out object defaultValue) {
|
|
if (parameterSubsegment.IsCatchAll) {
|
|
defaultValue = null;
|
|
return false;
|
|
}
|
|
|
|
return !defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultValue);
|
|
}
|
|
|
|
private static bool IsRoutePartNonEmpty(object routePart) {
|
|
string routePartString = routePart as string;
|
|
if (routePartString != null) {
|
|
return (routePartString.Length > 0);
|
|
}
|
|
return (routePart != null);
|
|
}
|
|
|
|
public RouteValueDictionary Match(string virtualPath, RouteValueDictionary defaultValues) {
|
|
IList<string> requestPathSegments = RouteParser.SplitUrlToPathSegmentStrings(virtualPath);
|
|
|
|
if (defaultValues == null) {
|
|
defaultValues = new RouteValueDictionary();
|
|
}
|
|
|
|
RouteValueDictionary matchedValues = new RouteValueDictionary();
|
|
|
|
// This flag gets set once all the data in the URL has been parsed through, but
|
|
// the route we're trying to match against still has more parts. At this point
|
|
// we'll only continue matching separator characters and parameters that have
|
|
// default values.
|
|
bool ranOutOfStuffToParse = false;
|
|
|
|
// This value gets set once we start processing a catchall parameter (if there is one
|
|
// at all). Once we set this value we consume all remaining parts of the URL into its
|
|
// parameter value.
|
|
bool usedCatchAllParameter = false;
|
|
|
|
for (int i = 0; i < PathSegments.Count; i++) {
|
|
PathSegment pathSegment = PathSegments[i];
|
|
|
|
if (requestPathSegments.Count <= i) {
|
|
ranOutOfStuffToParse = true;
|
|
}
|
|
|
|
string requestPathSegment = ranOutOfStuffToParse ? null : requestPathSegments[i];
|
|
|
|
if (pathSegment is SeparatorPathSegment) {
|
|
if (ranOutOfStuffToParse) {
|
|
// If we're trying to match a separator in the route but there's no more content, that's OK
|
|
}
|
|
else {
|
|
if (!String.Equals(requestPathSegment, "/", StringComparison.Ordinal)) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment;
|
|
if (contentPathSegment != null) {
|
|
if (contentPathSegment.IsCatchAll) {
|
|
Debug.Assert(i == (PathSegments.Count - 1), "If we're processing a catch-all, we should be on the last route segment.");
|
|
MatchCatchAll(contentPathSegment, requestPathSegments.Skip(i), defaultValues, matchedValues);
|
|
usedCatchAllParameter = true;
|
|
}
|
|
else {
|
|
if (!MatchContentPathSegment(contentPathSegment, requestPathSegment, defaultValues, matchedValues)) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path segment type");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!usedCatchAllParameter) {
|
|
if (PathSegments.Count < requestPathSegments.Count) {
|
|
// If we've already gone through all the parts defined in the route but the URL
|
|
// still contains more content, check that the remaining content is all separators.
|
|
for (int i = PathSegments.Count; i < requestPathSegments.Count; i++) {
|
|
if (!RouteParser.IsSeparator(requestPathSegments[i])) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Copy all remaining default values to the route data
|
|
if (defaultValues != null) {
|
|
foreach (var defaultValue in defaultValues) {
|
|
if (!matchedValues.ContainsKey(defaultValue.Key)) {
|
|
matchedValues.Add(defaultValue.Key, defaultValue.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
return matchedValues;
|
|
}
|
|
|
|
private void MatchCatchAll(ContentPathSegment contentPathSegment, IEnumerable<string> remainingRequestSegments, RouteValueDictionary defaultValues, RouteValueDictionary matchedValues) {
|
|
string remainingRequest = String.Join(String.Empty, remainingRequestSegments.ToArray());
|
|
|
|
ParameterSubsegment catchAllSegment = contentPathSegment.Subsegments[0] as ParameterSubsegment;
|
|
|
|
object catchAllValue;
|
|
|
|
if (remainingRequest.Length > 0) {
|
|
catchAllValue = remainingRequest;
|
|
}
|
|
else {
|
|
defaultValues.TryGetValue(catchAllSegment.ParameterName, out catchAllValue);
|
|
}
|
|
matchedValues.Add(catchAllSegment.ParameterName, catchAllValue);
|
|
}
|
|
|
|
private bool MatchContentPathSegment(ContentPathSegment routeSegment, string requestPathSegment, RouteValueDictionary defaultValues, RouteValueDictionary matchedValues) {
|
|
if (String.IsNullOrEmpty(requestPathSegment)) {
|
|
// If there's no data to parse, we must have exactly one parameter segment and no other segments - otherwise no match
|
|
|
|
if (routeSegment.Subsegments.Count > 1) {
|
|
return false;
|
|
}
|
|
|
|
ParameterSubsegment parameterSubsegment = routeSegment.Subsegments[0] as ParameterSubsegment;
|
|
if (parameterSubsegment == null) {
|
|
return false;
|
|
}
|
|
|
|
// We must have a default value since there's no value in the request URL
|
|
object parameterValue;
|
|
if (defaultValues.TryGetValue(parameterSubsegment.ParameterName, out parameterValue)) {
|
|
// If there's a default value for this parameter, use that default value
|
|
matchedValues.Add(parameterSubsegment.ParameterName, parameterValue);
|
|
return true;
|
|
}
|
|
else {
|
|
// If there's no default value, this segment doesn't match
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// Find last literal segment and get its last index in the string
|
|
|
|
int lastIndex = requestPathSegment.Length;
|
|
int indexOfLastSegmentUsed = routeSegment.Subsegments.Count - 1;
|
|
|
|
ParameterSubsegment parameterNeedsValue = null; // Keeps track of a parameter segment that is pending a value
|
|
LiteralSubsegment lastLiteral = null; // Keeps track of the left-most literal we've encountered
|
|
|
|
while (indexOfLastSegmentUsed >= 0) {
|
|
int newLastIndex = lastIndex;
|
|
|
|
ParameterSubsegment parameterSubsegment = routeSegment.Subsegments[indexOfLastSegmentUsed] as ParameterSubsegment;
|
|
if (parameterSubsegment != null) {
|
|
// Hold on to the parameter so that we can fill it in when we locate the next literal
|
|
parameterNeedsValue = parameterSubsegment;
|
|
}
|
|
else {
|
|
LiteralSubsegment literalSubsegment = routeSegment.Subsegments[indexOfLastSegmentUsed] as LiteralSubsegment;
|
|
if (literalSubsegment != null) {
|
|
lastLiteral = literalSubsegment;
|
|
|
|
int startIndex = lastIndex - 1;
|
|
// If we have a pending parameter subsegment, we must leave at least one character for that
|
|
if (parameterNeedsValue != null) {
|
|
startIndex--;
|
|
}
|
|
|
|
if (startIndex < 0) {
|
|
return false;
|
|
}
|
|
|
|
int indexOfLiteral = requestPathSegment.LastIndexOf(literalSubsegment.Literal, startIndex, StringComparison.OrdinalIgnoreCase);
|
|
if (indexOfLiteral == -1) {
|
|
// If we couldn't find this literal index, this segment cannot match
|
|
return false;
|
|
}
|
|
|
|
// If the first subsegment is a literal, it must match at the right-most extent of the request URL.
|
|
// Without this check if your route had "/Foo/" we'd match the request URL "/somethingFoo/".
|
|
// This check is related to the check we do at the very end of this function.
|
|
if (indexOfLastSegmentUsed == (routeSegment.Subsegments.Count - 1)) {
|
|
if ((indexOfLiteral + literalSubsegment.Literal.Length) != requestPathSegment.Length) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
newLastIndex = indexOfLiteral;
|
|
}
|
|
else {
|
|
Debug.Fail("Invalid path segment type");
|
|
}
|
|
}
|
|
|
|
if ((parameterNeedsValue != null) && (((lastLiteral != null) && (parameterSubsegment == null)) || (indexOfLastSegmentUsed == 0))) {
|
|
// If we have a pending parameter that needs a value, grab that value
|
|
|
|
int parameterStartIndex;
|
|
int parameterTextLength;
|
|
|
|
if (lastLiteral == null) {
|
|
if (indexOfLastSegmentUsed == 0) {
|
|
parameterStartIndex = 0;
|
|
}
|
|
else {
|
|
parameterStartIndex = newLastIndex;
|
|
Debug.Fail("indexOfLastSegementUsed should always be 0 from the check above");
|
|
}
|
|
parameterTextLength = lastIndex;
|
|
}
|
|
else {
|
|
// If we're getting a value for a parameter that is somewhere in the middle of the segment
|
|
if ((indexOfLastSegmentUsed == 0) && (parameterSubsegment != null)) {
|
|
parameterStartIndex = 0;
|
|
parameterTextLength = lastIndex;
|
|
}
|
|
else {
|
|
parameterStartIndex = newLastIndex + lastLiteral.Literal.Length;
|
|
parameterTextLength = lastIndex - parameterStartIndex;
|
|
}
|
|
}
|
|
|
|
string parameterValueString = requestPathSegment.Substring(parameterStartIndex, parameterTextLength);
|
|
|
|
if (String.IsNullOrEmpty(parameterValueString)) {
|
|
// If we're here that means we have a segment that contains multiple sub-segments.
|
|
// For these segments all parameters must have non-empty values. If the parameter
|
|
// has an empty value it's not a match.
|
|
return false;
|
|
}
|
|
else {
|
|
// If there's a value in the segment for this parameter, use the subsegment value
|
|
matchedValues.Add(parameterNeedsValue.ParameterName, parameterValueString);
|
|
}
|
|
|
|
parameterNeedsValue = null;
|
|
lastLiteral = null;
|
|
}
|
|
|
|
lastIndex = newLastIndex;
|
|
indexOfLastSegmentUsed--;
|
|
}
|
|
|
|
// If the last subsegment is a parameter, it's OK that we didn't parse all the way to the left extent of
|
|
// the string since the parameter will have consumed all the remaining text anyway. If the last subsegment
|
|
// is a literal then we *must* have consumed the entire text in that literal. Otherwise we end up matching
|
|
// the route "Foo" to the request URL "somethingFoo". Thus we have to check that we parsed the *entire*
|
|
// request URL in order for it to be a match.
|
|
// This check is related to the check we do earlier in this function for LiteralSubsegments.
|
|
return (lastIndex == 0) || (routeSegment.Subsegments[0] is ParameterSubsegment);
|
|
}
|
|
|
|
private static bool RoutePartsEqual(object a, object b) {
|
|
string sa = a as string;
|
|
string sb = b as string;
|
|
if (sa != null && sb != null) {
|
|
// For strings do a case-insensitive comparison
|
|
return String.Equals(sa, sb, StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
else {
|
|
if (a != null && b != null) {
|
|
// Explicitly call .Equals() in case it is overridden in the type
|
|
return a.Equals(b);
|
|
}
|
|
else {
|
|
// At least one of them is null. Return true if they both are
|
|
return a == b;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dev10 601636 Work around Uri.EscapeUriString not encoding #,&
|
|
private static string UrlEncode(string str) {
|
|
string escape = Uri.EscapeUriString(str);
|
|
return Regex.Replace(escape, "([#;?:@&=+$,])", new MatchEvaluator(EscapeReservedCharacters));
|
|
}
|
|
}
|
|
}
|