/// <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>
/// 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);
}