//Remove invalid objects from the list. Return true if any were removed. private bool ClearInvalidObjects(List<IStText> listToSearch, int offset, bool raiseChangeNotification) { bool didRemoveAny = false; for (int i = listToSearch.Count - 1; i >= 0; i--) { if (!listToSearch[i].IsValidObject || listToSearch[i].OwnerOfClass(ScrDraftTags.kClassId) != null) { // Enhance JohnT: if several are removed, especially close together, we might want // to combine the change notifications. However I think this will be quite unusual. if (m_interestingTests != null) m_interestingTests.Remove(listToSearch[i]); listToSearch.RemoveAt(i); if (raiseChangeNotification) RaiseInterestingTextsChanged(i + offset, 0, 1); didRemoveAny = true; } } return didRemoveAny; }
protected virtual void EnsureRealSegmentsForNonTrivialAnalyses(List<int> segments, int[] segmentsArray, int iseg, List<int> formsInSegment) { if (m_cache.IsDummyObject(segmentsArray[iseg]) && HasNonTrivialAnalysis(formsInSegment)) { using (SuppressSubTasks supressActionHandler = new SuppressSubTasks(Cache, true)) { // replace the dummy segment with a real one. segmentsArray[iseg] = CmBaseAnnotation.ConvertBaseAnnotationToReal(Cache, segmentsArray[iseg]).Hvo; segments.RemoveAt(iseg); segments.Insert(iseg, segmentsArray[iseg]); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Removes the invalid characters. /// </summary> /// <param name="list">The list.</param> /// ------------------------------------------------------------------------------------ private void RemoveInvalidCharacters(List<TextTokenSubstring> list) { // Getting one cpe and properly disposing it instead of creating a new cpe for every // character in the Bible solves TE-8420, plus it is many, many times faster. for (int i = list.Count - 1; i >= 0; i--) { if (!TsStringUtils.IsValidChar(list[i].InventoryText, m_chrPropEng)) list.RemoveAt(i); } }
/// <summary> /// Replace SortObjects corresponding to hvoToReplace with new SortObjects for newObj. /// </summary> /// <param name="newObj"></param> /// <param name="hvoToReplace"></param> /// <param name="fAssumeSame">if true, we'll try to replace sort objects for hvoToReplace with newObj at the same indices. /// if false, we'll rely upon sorter to merge the new item into the right index, or else add to the end. /// Enhance: Is there some way we can compare the sort/filter results for newObj and hvoToReplace that is hvo indepedendent?</param> /// <returns>resulting list of newSortItems added to SortedObjects</returns> protected ArrayList ReplaceListItem(ICmObject newObj, int hvoToReplace, bool fAssumeSame) { ArrayList newSortItems = new ArrayList(); // Note: don't check NeedToReloadVirtualProperty here, so we can update the list, even if we need to // reload it at a later time. This allows joining/breaking wordforms in the Concordance tools, without // necessarily having to reload the entire list. Typically replacements will be with real ids, and those // should be stable to add in the new view. //if (NeedToReloadVirtualProperty) // return newSortItems; // we don't need to update the list, if we're planning to reload the whole thing. List<int> indicesOfSortItemsToRemove = new List<int>(IndicesOfSortItems(new List<int>(new int[] { hvoToReplace }))); ArrayList remainingInsertItems = new ArrayList(); int hvoNewObject = 0; if (newObj != null) { hvoNewObject = newObj.Hvo; // we don't want to add new sort items, if we've already added them, but we do want to allow // a replacement. if (hvoToReplace == hvoNewObject || IndexOfFirstSortItem(new List<int>(new int[] { hvoNewObject })) < 0) MakeItemsFor(newSortItems, newObj); remainingInsertItems = (ArrayList)newSortItems.Clone(); if (fAssumeSame) { //assume we're converting a dummy item to a real one. //In that case, the real item should have same basic content as the dummy item we are replacing, //so we can replace the item at the same sortItem indices. foreach (object itemToInsert in newSortItems) { if (indicesOfSortItemsToRemove.Count > 0) { int iToReplace = indicesOfSortItemsToRemove[0]; SortedObjects.RemoveAt(iToReplace); SortedObjects.Insert(iToReplace, itemToInsert); indicesOfSortItemsToRemove.RemoveAt(0); remainingInsertItems.RemoveAt(0); } else { break; } } } } // Although, ideally, during a dummy conversion there should be a one-to-one correspondence between // the sort items found for the dummy object, and the sort items generated for its real object, // it's possible that at the time we added the dummy item to the record sort list, it didn't // have the same properties matching a filter or sorter as the real item. Try to do the best we // can by removing remaining sort items for the dummy object and then adding any additional sort items // for the real object. // remove the remaining items. indicesOfSortItemsToRemove.Sort(); indicesOfSortItemsToRemove.Reverse(); foreach (int iToRemove in indicesOfSortItemsToRemove) { SortedObjects.RemoveAt(iToRemove); } // add the remaining items. if (m_sorter != null) { m_sorter.MergeInto(SortedObjects, remainingInsertItems); } else { // Add at the end. SortedObjects.AddRange(remainingInsertItems); } // update our current selected hvo, if necessary if (m_hvoCurrent == hvoToReplace) m_hvoCurrent = hvoNewObject; return newSortItems; }