/// <summary> /// Creates the snapshot contexts. /// </summary> private void createSnapshotContexts() { foreach (Snapshot sourceSnapshot in sourceSnapshots) { SnapshotContext context = new SnapshotContext(sourceSnapshot); context.SourceStructure = sourceSnapshot.Structure.Readonly; context.SourceData = sourceSnapshot.CurrentData.Readonly; context.CallLevel = sourceSnapshot.CallLevel; context.ChangedIndexesTree = new MemoryIndexTree(); snapshotContexts.Add(context); } }
/// <summary> /// Collects the structure changes and find ancestor. /// </summary> /// <returns></returns> private IReadonlyChangeTracker <IReadOnlySnapshotStructure> collectStructureChangesAndFindAncestor() { SnapshotContext ancestorContext = snapshotContexts[0]; IReadonlyChangeTracker <IReadOnlySnapshotStructure> ancestor = ancestorContext.SourceStructure.ReadonlyChangeTracker; List <MemoryIndexTree> changes = new List <MemoryIndexTree>(); changes.Add(snapshotContexts[0].ChangedIndexesTree); for (int x = 1; x < snapshotContexts.Count; x++) { SnapshotContext context = snapshotContexts[x]; MemoryIndexTree currentChanges = context.ChangedIndexesTree; changes.Add(currentChanges); ancestor = getFirstCommonAncestor(context.SourceStructure.ReadonlyChangeTracker, ancestor, currentChanges, changes); } return(ancestor); }
/// <summary> /// Processes the merge operation. /// </summary> /// <param name="operation">The operation.</param> private void processMergeOperation(MergeOperation operation) { MemoryIndex targetIndex = operation.TargetIndex; var targetIndexDatasources = targetSnapshot.MergeInfo.GetOrCreateDatasourcesContaier(targetIndex); // Iterate sources foreach (MergeOperationContext operationContext in operation.Indexes) { // Retreive source context and definition MemoryIndex sourceIndex = operationContext.Index; SnapshotContext context = operationContext.SnapshotContext; IIndexDefinition sourceDefinition = context.SourceStructure.GetIndexDefinition(sourceIndex); // Collect array and aliases data arrayWorker.collectSourceArray(targetIndex, operation, operationContext, sourceDefinition.Array); aliasWorker.collectSourceAliases(sourceDefinition.Aliases); objectWorker.collectSourceObjects(sourceDefinition.Objects); // Store datasource for data and info merging targetIndexDatasources.SetDatasource(context.SourceSnapshot, sourceIndex); } IIndexDefinition targetDefinition; if (targetStructure.TryGetIndexDefinition(targetIndex, out targetDefinition)) { // Index is set in target snapshot if (targetDefinition.Array != null) { arrayWorker.SetTargetArray(targetDefinition.Array); } } else { // Index is not set in target snapshot - create it writeableTargetStructure.NewIndex(targetIndex); } aliasWorker.MergeAliasesAndClear(targetIndex, operation); arrayWorker.MergeArraysAndClear(targetSnapshot, targetIndex, operation); objectWorker.MergeObjectsAndClear(targetIndex); }
/// <summary> /// Collects the call structure changes. /// </summary> /// <param name="callSnapshot">The call snapshot.</param> private void collectCallStructureChanges(Snapshot callSnapshot) { List <MemoryIndexTree> changes = new List <MemoryIndexTree>(); var ancestor = callSnapshot.Structure.Readonly.ReadonlyChangeTracker; for (int x = 0; x < snapshotContexts.Count; x++) { SnapshotContext context = snapshotContexts[x]; MemoryIndexTree currentChanges = context.ChangedIndexesTree; changes.Add(currentChanges); collectSingleFunctionChanges(callSnapshot, context.SourceStructure.ReadonlyChangeTracker, currentChanges, changes); } if (targetSnapshot.StructureCallChanges != null) { CollectionMemoryUtils.AddAll(this.changeTree, targetSnapshot.StructureCallChanges); } targetSnapshot.StructureCallChanges = changeTree.StoredIndexes; }
/// <summary> /// Initializes a new instance of the <see cref="ContainerContext"/> class. /// </summary> /// <param name="context">The context.</param> /// <param name="indexContainer">The index container.</param> /// <param name="operationType">Type of the operation.</param> public ContainerContext(SnapshotContext context, IReadonlyIndexContainer indexContainer, MergeOperationType operationType = MergeOperationType.ChangedOnly) { this.SnapshotContext = context; this.IndexContainer = indexContainer; this.OperationType = operationType; }
/// <summary> /// Initializes a new instance of the <see cref="MergeOperationContext"/> class. /// </summary> /// <param name="index">The index.</param> /// <param name="snapshotContext">The snapshot context.</param> /// <param name="operationType">Type of the operation.</param> public MergeOperationContext(MemoryIndex index, SnapshotContext snapshotContext, MergeOperationType operationType = MergeOperationType.ChangedOnly) { this.Index = index; this.SnapshotContext = snapshotContext; this.OperationType = operationType; }