/// <summary>
/// Gets the alias information.
/// </summary>
/// <param name="index">The index.</param>
/// <returns></returns>
internal MemoryAliasInfo getAliasInfo(MemoryIndex index)
{
MemoryAliasInfo aliasInfo;
if (!MemoryAliases.TryGetValue(index, out aliasInfo))
{
IMemoryAliasBuilder alias = Factories.StructuralContainersFactories.MemoryAliasFactory.CreateMemoryAlias(writeableTargetStructure, index).Builder(writeableTargetStructure);
aliasInfo = new MemoryAliasInfo(alias, false);
MemoryAliases[index] = aliasInfo;
}
return(aliasInfo);
}
/// <summary>
/// Adds the aliases to given index. Alias entry of the given alias indexes are not changed.
/// If given memory index contains no aliases new alias entry is created.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="mustAlias">The must alias.</param>
/// <param name="mayAlias">The may alias.</param>
public void AddAlias(MemoryIndex index, MemoryIndex mustAlias, MemoryIndex mayAlias)
{
MemoryAliasInfo aliasInfo = getAliasInfo(index);
IMemoryAliasBuilder alias = aliasInfo.Aliases;
if (mustAlias != null)
{
alias.MustAliases.Add(mustAlias);
if (alias.MayAliases.Contains(mustAlias))
{
alias.MayAliases.Remove(mustAlias);
}
}
if (mayAlias != null && !alias.MustAliases.Contains(mayAlias))
{
alias.MayAliases.Add(mayAlias);
}
}
/// <summary>
/// Adds the aliases to given index. Alias entry of the given alias indexes are not changed.
/// If given memory index contains no aliases new alias entry is created.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="mustAliases">The must aliases.</param>
/// <param name="mayAliases">The may aliases.</param>
public void AddAliases(MemoryIndex index, IEnumerable <MemoryIndex> mustAliases, IEnumerable <MemoryIndex> mayAliases)
{
MemoryAliasInfo aliasInfo = getAliasInfo(index);
IMemoryAliasBuilder alias = aliasInfo.Aliases;
if (mustAliases != null)
{
alias.MustAliases.AddAll(mustAliases);
}
if (mayAliases != null)
{
alias.MayAliases.AddAll(mayAliases);
}
foreach (MemoryIndex mustIndex in alias.MustAliases)
{
if (alias.MayAliases.Contains(mustIndex))
{
alias.MayAliases.Remove(mustIndex);
}
}
}
private void processAliases(IMemoryAlias memoryAlias)
{
if (ProcessAliases)
{
// Assign new aliases if any
if (Node.HasAliases)
{
IEnumerable <MemoryIndex> aliases = Node.References.GetAllReferences();
foreach (MemoryIndex alias in aliases)
{
Worker.Snapshot.AddAlias(alias, null, TargetIndex);
}
Worker.Snapshot.MaySetAliases(TargetIndex, aliases);
}
// Must aliases has to be invalidated
else if (memoryAlias != null && memoryAlias.HasMustAliases)
{
IMemoryAliasBuilder builder = memoryAlias.Builder(Worker.Structure);
Worker.Snapshot.ConvertAliasesToMay(TargetIndex, builder);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MemoryAliasInfo"/> class.
/// </summary>
/// <param name="aliases">The aliases.</param>
/// <param name="isTargetOfMerge">if set to <c>true</c> [is target of merge].</param>
public MemoryAliasInfo(IMemoryAliasBuilder aliases, bool isTargetOfMerge)
{
this.Aliases = aliases;
this.IsTargetOfMerge = isTargetOfMerge;
this.removedAliases = new HashSet <MemoryIndex>();
}
