/// <summary>
/// Compares this structure object with given copy of old data and applies simplify limit when new memory entry is bigger than given simplify limit.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="simplifyLimit">The simplify limit.</param>
/// <param name="assistant">The assistant.</param>
/// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns>
private bool compareDataAndSimplify(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant)
{
HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>();
HashSetTools.AddAll(usedIndexes, this.IndexData.Keys);
HashSetTools.AddAll(usedIndexes, oldValue.IndexData.Keys);
IndexData emptyStructure = new CopyMemoryModel.IndexData(null, null, null);
bool areEqual = true;
foreach (MemoryIndex index in usedIndexes)
{
if (index is TemporaryIndex)
{
continue;
}
IndexData newStructure = getDataOrUndefined(index, this, emptyStructure);
IndexData oldStructure = getDataOrUndefined(index, oldValue, emptyStructure);
if (!newStructure.DataEquals(oldStructure))
{
areEqual = false;
}
if (!Data.DataEqualsAndSimplify(oldValue.Data, index, simplifyLimit, assistant))
{
areEqual = false;
}
}
return(areEqual);
}
/// <summary>
/// Compares this data structure with the given object.
/// </summary>
/// <param name="other">The other.</param>
/// <returns>True whether this instance contains the same values as the given one.</returns>
internal bool DataEquals(IndexData other)
{
if (this == other)
{
return(true);
}
if (this.Aliases != other.Aliases)
{
if (!MemoryAlias.AreEqual(Aliases, other.Aliases))
{
return(false);
}
}
if (this.Array != other.Array)
{
if (Array == null || other.Array == null || !this.Array.Equals(other.Array))
{
return(false);
}
}
if (this.Objects != other.Objects)
{
if (!ObjectValueContainer.AreEqual(Objects, other.Objects))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Compares this structure object with given copy of old data.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns>
private bool compareData(SnapshotStructure oldValue)
{
HashSet <MemoryIndex> usedIndexes = new HashSet <MemoryIndex>();
HashSetTools.AddAll(usedIndexes, this.IndexData.Keys);
HashSetTools.AddAll(usedIndexes, oldValue.IndexData.Keys);
IndexData emptyStructure = new CopyMemoryModel.IndexData(null, null, null);
foreach (MemoryIndex index in usedIndexes)
{
if (index is TemporaryIndex)
{
continue;
}
IndexData newStructure = getDataOrUndefined(index, this, emptyStructure);
IndexData oldStructure = getDataOrUndefined(index, oldValue, emptyStructure);
if (!newStructure.DataEquals(oldStructure))
{
return(false);
}
if (!Data.DataEquals(oldValue.Data, index))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Sets the array for specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="arrayValue">The array value.</param>
internal void SetArray(MemoryIndex index, AssociativeArray arrayValue)
{
lockedTest();
IndexData data;
if (!IndexData.TryGetValue(index, out data))
{
data = new IndexData(null, null, null);
}
IndexDataBuilder builder = data.Builder();
builder.Array = arrayValue;
IndexData[index] = builder.Build();
ArrayDescriptor descriptor;
if (TryGetDescriptor(arrayValue, out descriptor))
{
if (descriptor.ParentVariable != null)
{
Arrays[descriptor.ParentVariable.CallLevel].Remove(arrayValue);
}
}
Arrays[index.CallLevel].Add(arrayValue);
}
/// <summary>
/// Compares this structure object with given copy of old data and applies widening operation on memory entry which differs.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="simplifyLimit">The simplify limit.</param>
/// <param name="assistant">The assistant.</param>
/// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns>
private bool widenNotEqualData(SnapshotStructure oldValue, int simplifyLimit, MemoryAssistantBase assistant)
{
HashSet <MemoryIndex> indexes = new HashSet <MemoryIndex>();
HashSetTools.AddAll(indexes, this.IndexData.Keys);
HashSetTools.AddAll(indexes, oldValue.IndexData.Keys);
IndexData emptyData = new CopyMemoryModel.IndexData(null, null, null);
bool areEqual = true;
foreach (MemoryIndex index in indexes)
{
if (index is TemporaryIndex)
{
continue;
}
IndexData newData = getDataOrUndefined(index, this, emptyData);
IndexData oldData = getDataOrUndefined(index, oldValue, emptyData);
Data.DataWiden(oldValue.Data, index, assistant);
if (!Data.DataEqualsAndSimplify(oldValue.Data, index, simplifyLimit, assistant))
{
areEqual = false;
}
}
return(areEqual);
}
/// <summary>
/// Removes the index from structure and data.
/// </summary>
/// <param name="index">The index.</param>
internal void RemoveIndex(MemoryIndex index)
{
lockedTest();
IndexData.Remove(index);
Data.RemoveMemoryEntry(index);
}
/// <summary>
/// Insert newly created index into structure and data collection.
/// </summary>
/// <param name="index">The index.</param>
internal void NewIndex(MemoryIndex index)
{
lockedTest();
IndexData data = new IndexData(null, null, null);
IndexData[index] = data;
Data.SetMemoryEntry(index, new MemoryEntry(Snapshot.UndefinedValue));
}
/// <summary>
/// Gets the data of specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>Data of specified index.</returns>
/// <exception cref="System.Exception">Missing alias value for given index</exception>
internal IndexData GetIndexData(MemoryIndex index)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
return(data);
}
throw new Exception("Missing alias value for " + index);
}
/// <summary>
/// Gets the data is set in structure or returns given empty data.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="snapshotStructure">The snapshot structure.</param>
/// <param name="emptyData">The empty data.</param>
/// <returns>Data is set in structure or returns given empty data.</returns>
private CopyMemoryModel.IndexData getDataOrUndefined(MemoryIndex index, SnapshotStructure snapshotStructure, IndexData emptyData)
{
IndexData data = null;
if (!snapshotStructure.IndexData.TryGetValue(index, out data))
{
data = emptyData;
}
return(data);
}
/// <summary>
/// Gets the aliases for specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>Aliases for the specified index.</returns>
/// <exception cref="System.Exception">Missing alias value for + index</exception>
internal MemoryAlias GetAliases(MemoryIndex index)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
if (data.Aliases != null)
{
return(data.Aliases);
}
}
throw new Exception("Missing alias value for " + index);
}
/// <summary>
/// Determines whether the specified index has array.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>True whether the specified index has array.</returns>
internal bool HasArray(MemoryIndex index)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
return(data.Array != null);
}
else
{
return(false);
}
}
/// <summary>
/// Gets the array descriptor which contains information about defined indexes in the specified array.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>Array descriptor which contains information about defined indexes in the specified array.</returns>
/// <exception cref="System.Exception">Missing array for index + index</exception>
internal AssociativeArray GetArray(MemoryIndex index)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
if (data.Array != null)
{
return(data.Array);
}
}
throw new Exception("Missing array for index " + index);
}
/// <summary>
/// Gets the objects for given index.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>Collection of objects for given index.</returns>
public ObjectValueContainer GetObjects(MemoryIndex index)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
if (data.Objects != null)
{
return(data.Objects);
}
}
return(new ObjectValueContainer());
}
/// <summary>
/// Sets the memory entry to actual index data collection.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="memoryEntry">The memory entry.</param>
internal void SetMemoryEntry(MemoryIndex index, MemoryEntry memoryEntry)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
Data.SetMemoryEntry(index, memoryEntry);
}
else if (!Locked)
{
IndexData[index] = new IndexData(null, null, null);
Data.SetMemoryEntry(index, memoryEntry);
}
}
/// <summary>
/// Tries the get aliases for specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="aliases">The aliases.</param>
/// <returns>True whether specified index has aliases.</returns>
internal bool TryGetAliases(MemoryIndex index, out MemoryAlias aliases)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
aliases = data.Aliases;
return(data.Aliases != null);
}
else
{
aliases = null;
return(false);
}
}
/// <summary>
/// Tries to get array for specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="arrayValue">The array value.</param>
/// <returns>True whether the specified index has array.</returns>
internal bool TryGetArray(MemoryIndex index, out AssociativeArray arrayValue)
{
IndexData data;
if (IndexData.TryGetValue(index, out data))
{
arrayValue = data.Array;
return(data.Array != null);
}
else
{
arrayValue = null;
return(false);
}
}
/// <summary>
/// Sets objects for given index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="objects">The objects.</param>
internal void SetObjects(MemoryIndex index, ObjectValueContainer objects)
{
lockedTest();
IndexData data;
if (!IndexData.TryGetValue(index, out data))
{
data = new IndexData(null, null, null);
}
IndexDataBuilder builder = data.Builder();
builder.Objects = objects;
IndexData[index] = builder.Build();
}
/// <summary>
/// Removes the alias from specified index.
/// </summary>
/// <param name="index">The index.</param>
internal void RemoveAlias(MemoryIndex index)
{
lockedTest();
IndexData data;
if (!IndexData.TryGetValue(index, out data))
{
data = new IndexData(null, null, null);
}
IndexDataBuilder builder = data.Builder();
builder.Aliases = null;
IndexData[index] = builder.Build();
}
/// <summary>
/// Assigns the may memory index.
/// </summary>
/// <param name="mayIndex">Index of the may.</param>
/// <param name="composedValues">The composed values.</param>
private void assignMay(MemoryIndex mayIndex, CollectComposedValuesVisitor composedValues)
{
IndexData data = snapshot.Structure.GetIndexData(mayIndex);
HashSet <Value> values = new HashSet <Value>(composedValues.Values);
if (composedValues.Objects.Count > 0)
{
HashSet <ObjectValue> objects = new HashSet <ObjectValue>(data.Objects);
HashSetTools.AddAll(objects, composedValues.Objects);
snapshot.Structure.SetObjects(mayIndex, new ObjectValueContainer(objects));
//if (data.Objects != null)
HashSetTools.AddAll(values, data.Objects);
}
HashSetTools.AddAll(values, snapshot.Structure.GetMemoryEntry(mayIndex).PossibleValues);
snapshot.Structure.SetMemoryEntry(mayIndex, new MemoryEntry(values));
}
/// <summary>
/// Removes the array from specified index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="arrayValue">The array value.</param>
internal void RemoveArray(MemoryIndex index, AssociativeArray arrayValue)
{
lockedTest();
ArrayDescriptors.Remove(arrayValue);
IndexData data;
if (!IndexData.TryGetValue(index, out data))
{
data = new IndexData(null, null, null);
}
IndexDataBuilder builder = data.Builder();
builder.Array = null;
IndexData[index] = builder.Build();
Arrays[index.CallLevel].Remove(arrayValue);
}
/// <summary>
/// Assigns the must memory index.
/// </summary>
/// <param name="mustIndex">Index of the must.</param>
/// <param name="composedValues">The composed values.</param>
private void assignMust(MemoryIndex mustIndex, CollectComposedValuesVisitor composedValues)
{
IndexData data = snapshot.Structure.GetIndexData(mustIndex);
HashSet <Value> values = new HashSet <Value>(composedValues.Values);
if (data.Array != null)
{
values.Add(data.Array);
}
if (composedValues.Objects.Count > 0)
{
snapshot.Structure.SetObjects(mustIndex, new ObjectValueContainer(composedValues.Objects));
if (data.Objects != null)
{
HashSetTools.AddAll(values, data.Objects);
}
}
snapshot.Structure.SetMemoryEntry(mustIndex, new MemoryEntry(values));
}
/// <summary>
/// Initializes a new instance of the <see cref="IndexDataBuilder"/> class.
/// </summary>
/// <param name="data">The data.</param>
public IndexDataBuilder(IndexData data)
{
Aliases = data.Aliases;
Array = data.Array;
Objects = data.Objects;
}
/// <summary>
/// Determines whether the specified index is defined.
/// </summary>
/// <param name="index">The index.</param>
internal bool IsDefined(MemoryIndex index)
{
return(IndexData.ContainsKey(index));
}
/// <summary>
/// Tries to get data of given index.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="data">The data.</param>
/// <returns><c>true</c> if the data are same; otherwise, <c>false</c>.</returns>
internal bool TryGetIndexData(MemoryIndex index, out IndexData data)
{
return(IndexData.TryGetValue(index, out data));
}