/// <summary>
/// Creates merge operations for all indexes in the target collection. Source indexes for the operation are
/// retreived from the source collections. When there is missing index in some collection the operation set
/// to undefined.
///
/// This method is for both phases of analysis.
/// </summary>
public void MergeContainers()
{
// Process all names which has unassociated index and creates one
foreach (string indexName in undefinedIndexes)
{
writeableTargetContainer.AddIndex(indexName, targetIndex.CreateIndex(indexName));
}
foreach (var index in targetContainer.Indexes)
{
MergeOperation operation = new MergeOperation(index.Value);
worker.addOperation(operation);
if (isUndefined)
{
operation.SetUndefined();
}
foreach (var source in sources)
{
IReadonlyIndexContainer container = source.Item1;
Snapshot snapshot = source.Item2;
MemoryIndex containerIndex;
if (container.TryGetIndex(index.Key, out containerIndex))
{
operation.Add(containerIndex, snapshot);
}
else
{
operation.Add(container.UnknownIndex, snapshot);
}
}
}
}
/// <summary>
/// Stores given collection as the source of indexes and adds its unknown index into unknown operation.
/// Also gets all indexes from the source collection and inserts it into target collection.
///
/// This method is for the first phase of anaysis.
/// </summary>
/// <param name="sourceSnapshot">The source snapshot.</param>
/// <param name="sourceIndex">Index of the source.</param>
/// <param name="sourceContainer">The source container.</param>
public void CollectIndexes(
Snapshot sourceSnapshot,
MemoryIndex sourceIndex,
IReadonlyIndexContainer sourceContainer)
{
sources.Add(new Tuple <IReadonlyIndexContainer, Snapshot>(sourceContainer, sourceSnapshot));
unknownOperation.Add(sourceContainer.UnknownIndex, sourceSnapshot);
bool indexEquals = targetIndex.Equals(sourceIndex);
foreach (var index in sourceContainer.Indexes)
{
MemoryIndex containerIndex;
if (targetContainer.TryGetIndex(index.Key, out containerIndex))
{
if (containerIndex == null && indexEquals)
{
writeableTargetContainer.AddIndex(index.Key, index.Value);
undefinedIndexes.Remove(index.Key);
}
}
else if (indexEquals)
{
writeableTargetContainer.AddIndex(index.Key, index.Value);
}
else
{
writeableTargetContainer.AddIndex(index.Key, null);
undefinedIndexes.Add(index.Key);
}
}
}
public void MergeIndexes(MemoryIndex targetIndex, MemoryIndex sourceIndex)
{
if (!sourceIndex.IsPrefixOf(targetIndex) && !targetIndex.IsPrefixOf(sourceIndex))
{
MergeOperation operation = new MergeOperation(targetIndex);
operation.Add(targetIndex, targetSnapshot);
operation.Add(sourceIndex, targetSnapshot);
operation.IsRoot = true;
addOperation(operation);
arrayCount = 2;
processMerge();
}
}
/// <summary>
/// Creates merge operations for all temporary indexes in the target structure.
/// </summary>
/// <param name="index">The index.</param>
private void mergeTemporary(int index)
{
foreach (var temp in Structure.Readonly.GetReadonlyStackContext(index).ReadonlyTemporaryVariables)
{
MergeOperation operation = new MergeOperation(temp);
addOperation(operation);
foreach (Snapshot snapshot in sourceSnapshots)
{
if (snapshot.Structure.Readonly.IsDefined(temp))
{
operation.Add(temp, snapshot);
}
else
{
operation.SetUndefined();
}
}
}
}
/// <summary>
/// Creates merge operations for all temporary indexes in the target structure.
/// </summary>
/// <param name="index">The index.</param>
private void mergeTemporary(int index)
{
IWriteableSet <MemoryIndex> temporary = writeableStrucure.GetWriteableStackContext(index).WriteableTemporaryVariables;
foreach (var temp in temporary)
{
MergeOperation operation = new MergeOperation(temp);
addOperation(operation);
foreach (Snapshot snapshot in sourceSnapshots)
{
if (snapshot.Structure.Readonly.IsDefined(temp))
{
operation.Add(temp, snapshot);
}
else
{
operation.SetUndefined();
}
}
}
}
private AssociativeArray mergeArrays(
MemoryIndex targetIndex,
HashSet <AssociativeArray> arrays,
bool includeUndefined)
{
AssociativeArray arrayValue;
if (!targetSnapshot.Structure.Readonly.TryGetArray(targetIndex, out arrayValue))
{
arrayValue = targetSnapshot.CreateArray(targetIndex);
}
IArrayDescriptor newDescriptor = targetSnapshot.Structure.Readonly.GetDescriptor(arrayValue);
MergeOperation unknownMerge = new MergeOperation(newDescriptor.UnknownIndex);
unknownMerge.SetUndefined();
addOperation(unknownMerge);
HashSet <string> indexNames = new HashSet <string>();
foreach (AssociativeArray array in arrays)
{
foreach (Tuple <Snapshot, IArrayDescriptor> item in getIArrayDescriptor(array))
{
Snapshot snapshot = item.Item1;
IArrayDescriptor descriptor = item.Item2;
unknownMerge.Add(descriptor.UnknownIndex, snapshot);
foreach (var index in descriptor.Indexes)
{
indexNames.Add(index.Key);
}
}
}
foreach (string indexName in indexNames)
{
MergeOperation operation = new MergeOperation();
if (includeUndefined)
{
operation.SetUndefined();
}
foreach (var array in arrays)
{
foreach (Tuple <Snapshot, IArrayDescriptor> item in getIArrayDescriptor(array))
{
Snapshot snapshot = item.Item1;
IArrayDescriptor descriptor = item.Item2;
MemoryIndex sourceIndex;
if (descriptor.TryGetIndex(indexName, out sourceIndex))
{
operation.Add(sourceIndex, snapshot);
}
else
{
operation.Add(descriptor.UnknownIndex, snapshot);
}
}
}
MemoryIndex arrayIndex;
if (!newDescriptor.TryGetIndex(indexName, out arrayIndex))
{
arrayIndex = targetSnapshot.CreateIndex(indexName, arrayValue, true, false);
}
operation.SetTargetIndex(arrayIndex);
addOperation(operation);
}
return(arrayValue);
}
