public void UpdateIdentifiers(StringStore strings) { for (int i = 0; i < this.Count; ++i) { _nameIdentifier[i] = strings.GetSerializationIdentifier(_nameIdentifier[i]); } }
public void UpdateIdentifiers(StringStore strings) { // Remap all words *and merge pages with only casing differences* Dictionary <int, List <int> > remappedIndex = new Dictionary <int, List <int> >(_wordToItemsIndex.Count); foreach (int wordIdentifier in _wordToItemsIndex.Keys) { int updatedIdentifier = strings.GetSerializationIdentifier(wordIdentifier); Range wordMatches = strings.RangeForString(updatedIdentifier); int firstCaseInsensitiveWordIdentifier = wordMatches.Start; List <int> existingMatchesForWord; if (!remappedIndex.TryGetValue(firstCaseInsensitiveWordIdentifier, out existingMatchesForWord)) { // This is the first (or only) case-insensitive copy of the word - use the list we had remappedIndex[firstCaseInsensitiveWordIdentifier] = _wordToItemsIndex[wordIdentifier]; } else { // There are already values for another casing of this word. // Merge them to the current list in sorted order (this preserves ranking, if indexing was done in ranked order) existingMatchesForWord.AddRange(_wordToItemsIndex[wordIdentifier]); existingMatchesForWord.Sort(); } } _wordToItemsIndex = remappedIndex; }
public void StringStore_CaseSensitivity() { // Sample Strings: Not all in order, including casing differences, including duplicates StringStore store = new StringStore(); string[] strings = { "bool", "bool", "boolean", "Boolean", "BOOLEAN", "array", "Array", "aRRay", "ARRAY", "Array", "Collections", "ARR", "BIT" }; int[] addedIDs = new int[strings.Length]; // Add each value for (int i = 0; i < strings.Length; ++i) { addedIDs[i] = store.FindOrAddString(strings[i]); } // Verify each value comes back cased correctly (case sensitive add) for (int i = 0; i < strings.Length; ++i) { Assert.AreEqual(strings[i], store[addedIDs[i]].ToString()); } // Convert to Immutable store.ConvertToImmutable(); // Remap IDs for (int i = 0; i < strings.Length; ++i) { addedIDs[i] = store.GetSerializationIdentifier(addedIDs[i]); } // Verify each value comes back cased correctly (case sensitive values preserved on convert) for (int i = 0; i < strings.Length; ++i) { Assert.AreEqual(strings[i], store[addedIDs[i]].ToString()); } // Verify values have ascending IDs and are in case insensitive *stable* order string last = store[0].ToString(); for (int i = 1; i < store.Count; ++i) { string current = store[i].ToString(); // Verify all strings are in case insensitive order int cmp = string.Compare(last, current, StringComparison.OrdinalIgnoreCase); Assert.IsTrue(cmp <= 0); // Verify case-insensitive ties are in case sensitive order relative to each other if (cmp == 0) { Assert.IsTrue(string.Compare(last, current, StringComparison.Ordinal) < 0); } last = current; } // Verify searches return the range of capitalizations for the value byte[] buffer = new byte[20]; for (int i = 0; i < strings.Length; ++i) { String8 value8 = String8.Convert(strings[i], buffer); // Verify the string is found Range range; Assert.IsTrue(store.TryFindString(value8, out range)); // Verify the ID for the exact casing is reported within the range Assert.IsTrue(range.Contains(addedIDs[i])); // Verify every value in the range matches the value (case-insensitive) for (int j = range.Start; j <= range.End; ++j) { String8 otherMatch = store[j]; Assert.AreEqual(0, value8.CompareTo(otherMatch, true), String.Format("'{0}' in match range wasn't reported equal to '{1}' being matched", otherMatch, value8)); } // Verify the values just before and after the range don't match if (range.Start > 0) { String8 valueBefore = store[range.Start - 1]; Assert.IsTrue(value8.CompareTo(valueBefore, true) > 0, String.Format("'{0}' before match range wasn't reported before '{1}' being matched", valueBefore, value8)); } if (range.End < store.Count - 1) { String8 valueAfter = store[range.End + 1]; Assert.IsTrue(value8.CompareTo(valueAfter, true) < 0, String.Format("'{0}' after match range wasn't reported after '{1}' being matched", valueAfter, value8)); } // Ask for the case-sensitive range Range caseSensitive; Assert.IsTrue(store.TryFindString(value8, false, out caseSensitive)); // Verify every value in the range matches the value (case-sensitive) for (int j = caseSensitive.Start; j <= caseSensitive.End; ++j) { String8 otherMatch = store[j]; Assert.AreEqual(0, value8.CompareTo(otherMatch, false), String.Format("'{0}' in case sensitive range wasn't reported equal to '{1}' being matched", otherMatch, value8)); } // Verify the values just before and after the range don't match if (caseSensitive.Start > 0) { String8 valueBefore = store[caseSensitive.Start - 1]; Assert.IsTrue(value8.CompareTo(valueBefore, false) != 0, String.Format("'{0}' before case sensitive range still matches '{1}'", valueBefore, value8)); } if (caseSensitive.End < store.Count - 1) { String8 valueAfter = store[caseSensitive.End + 1]; Assert.IsTrue(value8.CompareTo(valueAfter, false) != 0, String.Format("'{0}' after case sensitive range still matches '{1}'", valueAfter, value8)); } } // Verify MakeCaseSensitive goes to empty if the provided casing isn't any of the values String8 BOOLean = String8.Convert("BOOLean", buffer); Range booleanRange; Assert.IsFalse(store.TryFindString(BOOLean, false, out booleanRange)); }
public void UpdateIdentifiers(StringStore store) { this.ParametersIdentifier = store.GetSerializationIdentifier(this.ParametersIdentifier); }