private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2) { // First see how the two items compare in a case insensitive fashion. Matches that // are strictly better (ignoring case) should prioritize the item. i.e. if we have // a prefix match, that should always be better than a substring match. // // The reason we ignore case is that it's very common for people to type expecting // completion to fix up their casing. i.e. 'false' will be written with the // expectation that it will get fixed by the completion list to 'False'. var diff = match1.CompareTo(match2, ignoreCase: true); if (diff != 0) { return(diff); } // If they both seemed just as good, but they differ on preselection, then // item1 is better if it is preselected, otherwise it is worse. if (item1.Rules.MatchPriority == MatchPriority.Preselect && item2.Rules.MatchPriority != MatchPriority.Preselect) { return(-1); } else if (item1.Rules.MatchPriority != MatchPriority.Preselect && item2.Rules.MatchPriority == MatchPriority.Preselect) { return(1); } // At this point we have two items which we're matching in a rather similar fasion. // If one is a prefix of the other, prefer the prefix. i.e. if we have // "Table" and "table:=" and the user types 't' and we are in a case insensitive // language, then we prefer the former. if (item1.DisplayText.Length != item2.DisplayText.Length) { var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; if (item2.DisplayText.StartsWith(item1.DisplayText, comparison)) { return(-1); } else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison)) { return(1); } } // Now compare the matches again in a case sensitive manner. If everything was // equal up to this point, we prefer the item that better matches based on case. diff = match1.CompareTo(match2, ignoreCase: false); if (diff != 0) { return(diff); } return(0); }
private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2) { // First see how the two items compare in a case insensitive fashion. Matches that // are strictly better (ignoring case) should prioritize the item. i.e. if we have // a prefix match, that should always be better than a substring match. // // The reason we ignore case is that it's very common for people to type expecting // completion to fix up their casing. i.e. 'false' will be written with the // expectation that it will get fixed by the completion list to 'False'. var diff = match1.CompareTo(match2, ignoreCase: true); if (diff != 0) { return(diff); } // Now, after comparing matches, check if an item wants to be preselected. If so, // we prefer that. i.e. say the user has typed 'f' and we have the items 'foo' // and 'False' (with the latter being 'Preselected'). Both will be a prefix match. // And because we are ignoring case, neither will be seen as better. Now, because // 'False' is preselected we pick it even though 'foo' matches 'f' case sensitively. diff = item2.Rules.MatchPriority - item1.Rules.MatchPriority; if (diff != 0) { return(diff); } // At this point we have two items which we're matching in a rather similar fasion. // If one is a prefix of the other, prefer the prefix. i.e. if we have // "Table" and "table:=" and the user types 't' and we are in a case insensitive // language, then we prefer the former. if (item1.DisplayText.Length != item2.DisplayText.Length) { var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; if (item2.DisplayText.StartsWith(item1.DisplayText, comparison)) { return(-1); } else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison)) { return(1); } } // Now compare the matches again in a case sensitive manner. If everything was // equal up to this point, we prefer the item that better matches based on case. diff = match1.CompareTo(match2, ignoreCase: false); if (diff != 0) { return(diff); } return(0); }
protected virtual int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2) { return(match1.CompareTo(match2)); }
protected virtual int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2) { return match1.CompareTo(match2); }
private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2) { // First see how the two items compare in a case insensitive fashion. Matches that // are strictly better (ignoring case) should prioritize the item. i.e. if we have // a prefix match, that should always be better than a substring match. // // The reason we ignore case is that it's very common for people to type expecting // completion to fix up their casing. i.e. 'false' will be written with the // expectation that it will get fixed by the completion list to 'False'. var diff = match1.CompareTo(match2, ignoreCase: true); if (diff != 0) { return diff; } // If they both seemed just as good, but they differ on preselection, then // item1 is better if it is preselected, otherwise it is worse. if (item1.Rules.MatchPriority == MatchPriority.Preselect && item2.Rules.MatchPriority != MatchPriority.Preselect) { return -1; } else if (item1.Rules.MatchPriority != MatchPriority.Preselect && item2.Rules.MatchPriority == MatchPriority.Preselect) { return 1; } // At this point we have two items which we're matching in a rather similar fasion. // If one is a prefix of the other, prefer the prefix. i.e. if we have // "Table" and "table:=" and the user types 't' and we are in a case insensitive // language, then we prefer the former. if (item1.DisplayText.Length != item2.DisplayText.Length) { var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; if (item2.DisplayText.StartsWith(item1.DisplayText, comparison)) { return -1; } else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison)) { return 1; } } // Now compare the matches again in a case sensitive manner. If everything was // equal up to this point, we prefer the item that better matches based on case. diff = match1.CompareTo(match2, ignoreCase: false); if (diff != 0) { return diff; } return 0; }
private int CompareMatches(PatternMatch match1, PatternMatch match2, CompletionItem item1, CompletionItem item2) { // First see how the two items compare in a case insensitive fashion. Matches that // are strictly better (ignoring case) should prioritize the item. i.e. if we have // a prefix match, that should always be better than a substring match. // // The reason we ignore case is that it's very common for people to type expecting // completion to fix up their casing. i.e. 'false' will be written with the // expectation that it will get fixed by the completion list to 'False'. var diff = match1.CompareTo(match2, ignoreCase: true); if (diff != 0) { return diff; } // Now, after comparing matches, check if an item wants to be preselected. If so, // we prefer that. i.e. say the user has typed 'f' and we have the items 'foo' // and 'False' (with the latter being 'Preselected'). Both will be a prefix match. // And because we are ignoring case, neither will be seen as better. Now, because // 'False' is preselected we pick it even though 'foo' matches 'f' case sensitively. diff = item2.Rules.MatchPriority - item1.Rules.MatchPriority; if (diff != 0) { return diff; } // At this point we have two items which we're matching in a rather similar fasion. // If one is a prefix of the other, prefer the prefix. i.e. if we have // "Table" and "table:=" and the user types 't' and we are in a case insensitive // language, then we prefer the former. if (item1.DisplayText.Length != item2.DisplayText.Length) { var comparison = _isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; if (item2.DisplayText.StartsWith(item1.DisplayText, comparison)) { return -1; } else if (item1.DisplayText.StartsWith(item2.DisplayText, comparison)) { return 1; } } // Now compare the matches again in a case sensitive manner. If everything was // equal up to this point, we prefer the item that better matches based on case. diff = match1.CompareTo(match2, ignoreCase: false); if (diff != 0) { return diff; } return 0; }