/// <summary></summary>
public virtual void RemoveNodeRange(IWriteableListInner inner, int firstNodeIndex, int lastNodeIndex)
{
Contract.RequireNotNull(inner, out IWriteableListInner Inner);
Debug.Assert(firstNodeIndex >= 0 && firstNodeIndex < Inner.StateList.Count);
Debug.Assert(lastNodeIndex >= 0 && lastNodeIndex <= Inner.StateList.Count);
Debug.Assert(firstNodeIndex <= lastNodeIndex);
System.Action <IWriteableOperation> HandlerRedoNode = (IWriteableOperation operation) => RedoRemoveNode(operation);
System.Action <IWriteableOperation> HandlerUndoNode = (IWriteableOperation operation) => UndoRemoveNode(operation);
WriteableOperationList OperationList = CreateOperationList();
for (int i = firstNodeIndex; i < lastNodeIndex; i++)
{
WriteableRemoveNodeOperation OperationNode = CreateRemoveNodeOperation(Inner.Owner.Node, Inner.PropertyName, -1, firstNodeIndex, HandlerRedoNode, HandlerUndoNode, isNested: true);
OperationList.Add(OperationNode);
}
if (OperationList.Count > 0)
{
WriteableOperationReadOnlyList OperationReadOnlyList = OperationList.ToReadOnly();
System.Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => RedoRefresh(operation);
System.Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => throw new NotImplementedException(); // Undo is not possible.
WriteableGenericRefreshOperation RefreshOperation = CreateGenericRefreshOperation(RootState, HandlerRedo, HandlerUndo, isNested: false);
WriteableOperationGroup OperationGroup = CreateOperationGroup(OperationReadOnlyList, RefreshOperation);
OperationGroup.Redo();
SetLastOperation(OperationGroup);
CheckInvariant();
}
}
/// <summary>
/// Split an identifier with replace and insert indexes.
/// </summary>
/// <param name="inner">The inner where the node is replaced.</param>
/// <param name="replaceIndex">Index for the replace operation.</param>
/// <param name="insertIndex">Index for the insert operation.</param>
/// <param name="firstIndex">Index of the replacing node upon return.</param>
/// <param name="secondIndex">Index of the inserted node upon return.</param>
public virtual void SplitIdentifier(IWriteableListInner inner, IWriteableInsertionListNodeIndex replaceIndex, IWriteableInsertionListNodeIndex insertIndex, out IWriteableBrowsingListNodeIndex firstIndex, out IWriteableBrowsingListNodeIndex secondIndex)
{
Contract.RequireNotNull(inner, out IWriteableListInner Inner);
Contract.RequireNotNull(replaceIndex, out IWriteableInsertionListNodeIndex ReplaceIndex);
Contract.RequireNotNull(insertIndex, out IWriteableInsertionListNodeIndex InsertIndex);
IWriteableNodeState Owner = Inner.Owner;
IWriteableIndex ParentIndex = Owner.ParentIndex;
Debug.Assert(Contains(ParentIndex));
Debug.Assert(IndexToState(ParentIndex) == Owner);
WriteableInnerReadOnlyDictionary <string> InnerTable = Owner.InnerTable;
Debug.Assert(InnerTable.ContainsKey(Inner.PropertyName));
Debug.Assert(InnerTable[Inner.PropertyName] == Inner);
int Index = ReplaceIndex.Index;
Debug.Assert(InsertIndex.Index == Index + 1);
Node ReplacingNode = ReplaceIndex.Node;
Node InsertedNode = InsertIndex.Node;
Action <IWriteableOperation> HandlerRedoReplace = (IWriteableOperation operation) => RedoReplace(operation);
Action <IWriteableOperation> HandlerUndoReplace = (IWriteableOperation operation) => UndoReplace(operation);
IWriteableReplaceOperation ReplaceOperation = CreateReplaceOperation(Inner.Owner.Node, Inner.PropertyName, -1, Index, clearNode: false, ReplacingNode, HandlerRedoReplace, HandlerUndoReplace, isNested: true);
Action <IWriteableOperation> HandlerRedoInsert = (IWriteableOperation operation) => RedoInsertNewNode(operation);
Action <IWriteableOperation> HandlerUndoInsert = (IWriteableOperation operation) => UndoInsertNewNode(operation);
WriteableInsertNodeOperation InsertOperation = CreateInsertNodeOperation(Inner.Owner.Node, Inner.PropertyName, -1, Index + 1, InsertedNode, HandlerRedoInsert, HandlerUndoInsert, isNested: true);
ReplaceOperation.Redo();
InsertOperation.Redo();
Action <IWriteableOperation> HandlerRedoRefresh = (IWriteableOperation operation) => RedoRefresh(operation);
Action <IWriteableOperation> HandlerUndoRefresh = (IWriteableOperation operation) => throw new NotImplementedException(); // Undo is not possible.
WriteableGenericRefreshOperation RefreshOperation = CreateGenericRefreshOperation(RootState, HandlerRedoRefresh, HandlerUndoRefresh, isNested: false);
RefreshOperation.Redo();
WriteableOperationList OperationList = CreateOperationList();
OperationList.Add(ReplaceOperation);
OperationList.Add(InsertOperation);
WriteableOperationReadOnlyList OperationReadOnlyList = OperationList.ToReadOnly();
WriteableOperationGroup OperationGroup = CreateOperationGroup(OperationReadOnlyList, RefreshOperation);
SetLastOperation(OperationGroup);
CheckInvariant();
firstIndex = ReplaceOperation.NewBrowsingIndex as IWriteableBrowsingListNodeIndex;
Debug.Assert(firstIndex != null);
secondIndex = InsertOperation.BrowsingIndex as IWriteableBrowsingListNodeIndex;
Debug.Assert(secondIndex != null);
}
private protected virtual void PruneListInner(IWriteableListInner <IWriteableBrowsingListNodeIndex> inner)
{
foreach (IWriteableNodeState State in inner.StateList)
{
PruneState(State);
Stats.PlaceholderNodeCount--;
}
Stats.ListCount--;
}
private protected virtual bool IsNodeRangeRemoveable(IWriteableListInner inner, int firstNodeIndex, int lastNodeIndex)
{
Contract.RequireNotNull(inner, out IWriteableListInner Inner);
Debug.Assert(firstNodeIndex >= 0 && firstNodeIndex < Inner.StateList.Count);
Debug.Assert(lastNodeIndex >= 0 && lastNodeIndex <= Inner.StateList.Count);
Debug.Assert(firstNodeIndex <= lastNodeIndex);
int DeletedCount = lastNodeIndex - firstNodeIndex;
return(Inner.StateList.Count > DeletedCount);
}
/// <summary></summary>
public virtual void InsertNodeRange(IWriteableListInner inner, int insertedIndex, IList <IWriteableInsertionCollectionNodeIndex> indexList)
{
Contract.RequireNotNull(inner, out IWriteableListInner Inner);
Debug.Assert(insertedIndex >= 0 && insertedIndex <= Inner.StateList.Count);
int BlockNodeIndex = insertedIndex;
foreach (IWriteableInsertionCollectionNodeIndex NodeIndex in indexList)
{
bool IsHandled = false;
if (NodeIndex is IWriteableInsertionListNodeIndex AsListNodeIndex)
{
Debug.Assert(AsListNodeIndex.Index == BlockNodeIndex);
BlockNodeIndex++;
IsHandled = true;
}
Debug.Assert(IsHandled);
}
int FinalNodeIndex = BlockNodeIndex;
Action <IWriteableOperation> HandlerRedoInsertNode = (IWriteableOperation operation) => RedoInsertNewNode(operation);
Action <IWriteableOperation> HandlerUndoInsertNode = (IWriteableOperation operation) => UndoInsertNewNode(operation);
WriteableOperationList OperationList = CreateOperationList();
foreach (IWriteableInsertionCollectionNodeIndex NodeIndex in indexList)
{
if (NodeIndex is IWriteableInsertionListNodeIndex AsListNodeIndex)
{
IndexToPositionAndNode(AsListNodeIndex, out int BlockIndex, out int Index, out _, out Node Node);
WriteableInsertNodeOperation OperationInsertNode = CreateInsertNodeOperation(Inner.Owner.Node, Inner.PropertyName, BlockIndex, Index, Node, HandlerRedoInsertNode, HandlerUndoInsertNode, isNested: true);
OperationList.Add(OperationInsertNode);
}
}
if (OperationList.Count > 0)
{
WriteableOperationReadOnlyList OperationReadOnlyList = OperationList.ToReadOnly();
Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => RedoRefresh(operation);
Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => throw new NotImplementedException(); // Undo is not possible.
WriteableGenericRefreshOperation RefreshOperation = CreateGenericRefreshOperation(RootState, HandlerRedo, HandlerUndo, isNested: false);
WriteableOperationGroup OperationGroup = CreateOperationGroup(OperationReadOnlyList, RefreshOperation);
OperationGroup.Redo();
SetLastOperation(OperationGroup);
CheckInvariant();
}
}