/// <summary>
/// Restores the cycle index list from which this state was created.
/// </summary>
/// <param name="cycleIndexList">The list to restore.</param>
public virtual void RestoreCycleIndexList(IFocusInsertionChildNodeIndexList cycleIndexList)
{
Debug.Assert(cycleIndexList != null && cycleIndexList.Count >= 2);
Debug.Assert(CycleIndexList == null);
CycleIndexList = cycleIndexList;
}
/// <summary>
/// Replace an existing node with a new one, keeping its cycle.
/// </summary>
/// <param name="inner">The inner where the node is replaced.</param>
/// <param name="cycleIndexList">Cycle of nodes that can replace the current node.</param>
/// <param name="cyclePosition">New position in the cycle.</param>
/// <param name="nodeIndex">Index of the replacing node upon return.</param>
public virtual void Replace(IFocusInner inner, IFocusInsertionChildNodeIndexList cycleIndexList, int cyclePosition, out IFocusBrowsingChildIndex nodeIndex)
{
Debug.Assert(cycleIndexList != null);
Debug.Assert(cycleIndexList.Count >= 2);
Debug.Assert(cyclePosition >= 0 && cyclePosition < cycleIndexList.Count);
IFocusInsertionChildNodeIndex ReplacementIndex = cycleIndexList[cyclePosition];
IndexToPositionAndNode(ReplacementIndex, out int BlockIndex, out int Index, out INode Node);
Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => ExecuteReplaceWithCycle(operation);
Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => UndoReplaceWithCycle(operation);
IFocusReplaceWithCycleOperation Operation = CreateReplaceWithCycleOperation(inner.Owner.Node, inner.PropertyName, BlockIndex, Index, cycleIndexList, cyclePosition, HandlerRedo, HandlerUndo, isNested: false);
ExecuteReplaceWithCycle(Operation);
nodeIndex = Operation.NewBrowsingIndex;
SetLastOperation(Operation);
CheckInvariant();
}
/// <summary></summary>
protected override void AddNextNodeToCycle(IFocusCyclableNodeState state)
{
IFocusInsertionChildNodeIndexList CycleIndexList = state.CycleIndexList;
INode ParentNode = state.ParentState.Node;
IFocusIndex NodeIndex = state.ParentIndex;
IDocument Documentation = null;
IBlockList <IAssertion, Assertion> RequireBlocks = null;
IBlockList <IAssertion, Assertion> EnsureBlocks = null;
IBlockList <IIdentifier, Identifier> ExceptionIdentifierBlocks = null;
IBlockList <IEntityDeclaration, EntityDeclaration> EntityDeclarationBlocks = null;
IBlockList <IInstruction, Instruction> BodyInstructionBlocks = null;
IBlockList <IExceptionHandler, ExceptionHandler> ExceptionHandlerBlocks = null;
IOptionalReference <IObjectType> AncestorType = null;
List <Type> BodyTypeList = new List <Type>()
{
typeof(EffectiveBody), typeof(DeferredBody), typeof(ExternBody), typeof(PrecursorBody)
};
foreach (IFocusInsertionChildNodeIndex Index in CycleIndexList)
{
IBody Body = Index.Node as IBody;
Debug.Assert(Body != null);
if (BodyTypeList.Contains(Body.GetType()))
{
BodyTypeList.Remove(Body.GetType());
}
switch (Body)
{
case IEffectiveBody AsEffective:
Documentation = AsEffective.Documentation;
RequireBlocks = AsEffective.RequireBlocks;
EnsureBlocks = AsEffective.EnsureBlocks;
ExceptionIdentifierBlocks = AsEffective.ExceptionIdentifierBlocks;
EntityDeclarationBlocks = AsEffective.EntityDeclarationBlocks;
BodyInstructionBlocks = AsEffective.BodyInstructionBlocks;
ExceptionHandlerBlocks = AsEffective.ExceptionHandlerBlocks;
break;
case IDeferredBody AsDeferred:
Documentation = AsDeferred.Documentation;
RequireBlocks = AsDeferred.RequireBlocks;
EnsureBlocks = AsDeferred.EnsureBlocks;
ExceptionIdentifierBlocks = AsDeferred.ExceptionIdentifierBlocks;
break;
case IExternBody AsExtern:
Documentation = AsExtern.Documentation;
RequireBlocks = AsExtern.RequireBlocks;
EnsureBlocks = AsExtern.EnsureBlocks;
ExceptionIdentifierBlocks = AsExtern.ExceptionIdentifierBlocks;
break;
case IPrecursorBody AsPrecursor:
Documentation = AsPrecursor.Documentation;
RequireBlocks = AsPrecursor.RequireBlocks;
EnsureBlocks = AsPrecursor.EnsureBlocks;
ExceptionIdentifierBlocks = AsPrecursor.ExceptionIdentifierBlocks;
AncestorType = AsPrecursor.AncestorType;
break;
}
}
// If the list is full, no need to add more nodes to the cycle.
if (BodyTypeList.Count > 0)
{
Type NodeType = BodyTypeList[0];
INode NewBody = NodeHelper.CreateInitializedBody(NodeType, Documentation, RequireBlocks, EnsureBlocks, ExceptionIdentifierBlocks, EntityDeclarationBlocks, BodyInstructionBlocks, ExceptionHandlerBlocks, AncestorType);
IFocusBrowsingInsertableIndex InsertableNodeIndex = NodeIndex as IFocusBrowsingInsertableIndex;
Debug.Assert(InsertableNodeIndex != null);
IFocusInsertionChildNodeIndex InsertionIndex = InsertableNodeIndex.ToInsertionIndex(ParentNode, NewBody) as IFocusInsertionChildNodeIndex;
Debug.Assert(InsertionIndex != null);
CycleIndexList.Add(InsertionIndex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FocusReplaceWithCycleOperation"/> class.
/// </summary>
/// <param name="parentNode">Node where the replacement is taking place.</param>
/// <param name="propertyName">Property of <paramref name="parentNode"/> where the node is replaced.</param>
/// <param name="blockIndex">Block position where the node is replaced, if applicable.</param>
/// <param name="index">Position where the node is replaced, if applicable.</param>
/// <param name="cycleIndexList">Cycle of nodes that can replace the current node.</param>
/// <param name="cyclePosition">New position in the cycle.</param>
/// <param name="handlerRedo">Handler to execute to redo the operation.</param>
/// <param name="handlerUndo">Handler to execute to undo the operation.</param>
/// <param name="isNested">True if the operation is nested within another more general one.</param>
public FocusReplaceWithCycleOperation(INode parentNode, string propertyName, int blockIndex, int index, IFocusInsertionChildNodeIndexList cycleIndexList, int cyclePosition, Action <IWriteableOperation> handlerRedo, Action <IWriteableOperation> handlerUndo, bool isNested)
: base(parentNode, propertyName, blockIndex, index, cycleIndexList[cyclePosition].Node, handlerRedo, handlerUndo, isNested)
{
CycleIndexList = cycleIndexList;
NewCyclePosition = cyclePosition;
}
/// <summary>
/// Creates a IxxxReplaceOperation object.
/// </summary>
private protected virtual IFocusReplaceWithCycleOperation CreateReplaceWithCycleOperation(int blockIndex, int index, IFocusInsertionChildNodeIndexList cycleIndexList, int cyclePosition, Action <IWriteableOperation> handlerRedo, Action <IWriteableOperation> handlerUndo, bool isNested)
{
ControllerTools.AssertNoOverride(this, typeof(FocusReplaceWithCycleOperation));
return(new FocusReplaceWithCycleOperation(ParentNode, PropertyName, blockIndex, index, cycleIndexList, cyclePosition, handlerRedo, handlerUndo, isNested));
}
/// <summary></summary>
protected override void AddNextNodeToCycle(IFocusCyclableNodeState state)
{
IFocusInsertionChildNodeIndexList CycleIndexList = state.CycleIndexList;
INode ParentNode = state.ParentState.Node;
IFocusNodeIndex NodeIndex = state.ParentIndex as IFocusNodeIndex;
IDocument Documentation = null;
IIdentifier ExportIdentifier = null;
ExportStatus Export = ExportStatus.Exported;
IName EntityName = null;
IObjectType EntityType = null;
IBlockList <IAssertion, Assertion> EnsureBlocks = null;
IExpression ConstantValue = null;
IBlockList <ICommandOverload, CommandOverload> CommandOverloadBlocks = null;
OnceChoice Once = OnceChoice.Normal;
IBlockList <IQueryOverload, QueryOverload> QueryOverloadBlocks = null;
UtilityType PropertyKind = UtilityType.ReadWrite;
IBlockList <IIdentifier, Identifier> ModifiedQueryBlocks = null;
IOptionalReference <IBody> GetterBody = null;
IOptionalReference <IBody> SetterBody = null;
IBlockList <IEntityDeclaration, EntityDeclaration> IndexParameterBlocks = null;
ParameterEndStatus ParameterEnd = ParameterEndStatus.Closed;
List <Type> FeatureTypeList = new List <Type>()
{
typeof(AttributeFeature), typeof(ConstantFeature), typeof(CreationFeature), typeof(FunctionFeature), typeof(ProcedureFeature), typeof(PropertyFeature), typeof(IndexerFeature)
};
foreach (IFocusInsertionChildNodeIndex Index in CycleIndexList)
{
IFeature Feature = Index.Node as IFeature;
Debug.Assert(Feature != null);
if (FeatureTypeList.Contains(Feature.GetType()))
{
FeatureTypeList.Remove(Feature.GetType());
}
switch (Feature)
{
case IAttributeFeature AsAttribute:
Documentation = AsAttribute.Documentation;
ExportIdentifier = AsAttribute.ExportIdentifier;
Export = AsAttribute.Export;
EntityName = AsAttribute.EntityName;
EntityType = AsAttribute.EntityType;
EnsureBlocks = AsAttribute.EnsureBlocks;
break;
case IConstantFeature AsConstant:
Documentation = AsConstant.Documentation;
ExportIdentifier = AsConstant.ExportIdentifier;
Export = AsConstant.Export;
EntityName = AsConstant.EntityName;
EntityType = AsConstant.EntityType;
ConstantValue = AsConstant.ConstantValue;
break;
case ICreationFeature AsCreation:
Documentation = AsCreation.Documentation;
ExportIdentifier = AsCreation.ExportIdentifier;
Export = AsCreation.Export;
EntityName = AsCreation.EntityName;
CommandOverloadBlocks = AsCreation.OverloadBlocks;
break;
case IFunctionFeature AsFunction:
Documentation = AsFunction.Documentation;
ExportIdentifier = AsFunction.ExportIdentifier;
Export = AsFunction.Export;
EntityName = AsFunction.EntityName;
Once = AsFunction.Once;
QueryOverloadBlocks = AsFunction.OverloadBlocks;
break;
case IProcedureFeature AsProcedure:
Documentation = AsProcedure.Documentation;
ExportIdentifier = AsProcedure.ExportIdentifier;
Export = AsProcedure.Export;
EntityName = AsProcedure.EntityName;
CommandOverloadBlocks = AsProcedure.OverloadBlocks;
break;
case IPropertyFeature AsProperty:
Documentation = AsProperty.Documentation;
ExportIdentifier = AsProperty.ExportIdentifier;
Export = AsProperty.Export;
EntityName = AsProperty.EntityName;
EntityType = AsProperty.EntityType;
PropertyKind = AsProperty.PropertyKind;
ModifiedQueryBlocks = AsProperty.ModifiedQueryBlocks;
GetterBody = AsProperty.GetterBody;
SetterBody = AsProperty.SetterBody;
break;
case IIndexerFeature AsIndexer:
Documentation = AsIndexer.Documentation;
ExportIdentifier = AsIndexer.ExportIdentifier;
Export = AsIndexer.Export;
EntityType = AsIndexer.EntityType;
IndexParameterBlocks = AsIndexer.IndexParameterBlocks;
ParameterEnd = AsIndexer.ParameterEnd;
ModifiedQueryBlocks = AsIndexer.ModifiedQueryBlocks;
GetterBody = AsIndexer.GetterBody;
SetterBody = AsIndexer.SetterBody;
break;
}
Debug.Assert(CommandOverloadBlocks == null || CommandOverloadBlocks.NodeBlockList.Count > 0);
Debug.Assert(QueryOverloadBlocks == null || QueryOverloadBlocks.NodeBlockList.Count > 0);
Debug.Assert(IndexParameterBlocks == null || IndexParameterBlocks.NodeBlockList.Count > 0);
}
// If the list is full, no need to add more nodes to the cycle.
if (FeatureTypeList.Count > 0)
{
Type NodeType = FeatureTypeList[0];
INode NewFeature = NodeHelper.CreateInitializedFeature(NodeType, Documentation, ExportIdentifier, Export, EntityName, EntityType, EnsureBlocks, ConstantValue, CommandOverloadBlocks, Once, QueryOverloadBlocks, PropertyKind, ModifiedQueryBlocks, GetterBody, SetterBody, IndexParameterBlocks, ParameterEnd);
IFocusInsertionChildNodeIndex InsertionIndex = (IFocusInsertionChildNodeIndex)((IFocusBrowsingInsertableIndex)NodeIndex).ToInsertionIndex(ParentNode, NewFeature);
CycleIndexList.Add(InsertionIndex);
}
}
/// <summary>
/// Creates a IxxxReplaceWithCycleOperation object.
/// </summary>
private protected override IFocusReplaceWithCycleOperation CreateReplaceWithCycleOperation(INode parentNode, string propertyName, int blockIndex, int index, IFocusInsertionChildNodeIndexList cycleIndexList, int cyclePosition, Action <IWriteableOperation> handlerRedo, Action <IWriteableOperation> handlerUndo, bool isNested)
{
ControllerTools.AssertNoOverride(this, typeof(LayoutController));
return(new LayoutReplaceWithCycleOperation(parentNode, propertyName, blockIndex, index, (ILayoutInsertionChildNodeIndexList)cycleIndexList, cyclePosition, handlerRedo, handlerUndo, isNested));
}
