/// <summary>
/// Initializes a new instance of the <see cref="LazyCopyIndexDefinition" /> class.
/// </summary>
/// <param name="writeableSnapshotStrucure">The writeable snapshot strucure.</param>
/// <param name="indexDefinition">The index definition.</param>
public LazyCopyIndexDefinition(IWriteableSnapshotStructure writeableSnapshotStrucure, LazyCopyIndexDefinition indexDefinition)
{
this.aliases = indexDefinition.aliases;
this.objects = indexDefinition.objects;
this.arrayValue = indexDefinition.arrayValue;
this.associatedStructure = writeableSnapshotStrucure;
}
/// <summary>
/// Processes the source aliases.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="memoryAlias">The memory alias.</param>
private void processSourceAliases(MemoryCollectorNode node, IMemoryAlias memoryAlias)
{
if (memoryAlias != null && memoryAlias.HasAliases)
{
if (node.IsMust)
{
foreach (MemoryIndex alias in memoryAlias.MustAliases)
{
Snapshot.AddAlias(alias, node.TargetIndex, null);
}
foreach (MemoryIndex alias in memoryAlias.MayAliases)
{
Snapshot.AddAlias(alias, null, node.TargetIndex);
}
Snapshot.MustSetAliases(node.TargetIndex, memoryAlias.MustAliases, memoryAlias.MayAliases);
}
else
{
HashSet <MemoryIndex> aliases = new HashSet <MemoryIndex>();
CollectionMemoryUtils.AddAll(aliases, memoryAlias.MustAliases);
CollectionMemoryUtils.AddAll(aliases, memoryAlias.MayAliases);
foreach (MemoryIndex alias in aliases)
{
Snapshot.AddAlias(alias, null, node.TargetIndex);
}
Snapshot.MaySetAliases(node.TargetIndex, aliases);
}
}
}
private void processAliases(IMemoryAlias memoryAlias)
{
if (ProcessAliases)
{
// Destroys old aliases if any
if (memoryAlias != null && memoryAlias.HasAliases)
{
Worker.Snapshot.DestroyAliases(TargetIndex);
}
}
}
/// <summary>
/// Deletes the aliases.
/// </summary>
/// <param name="targetIndex">Index of the target.</param>
/// <param name="targetAliases">The target aliases.</param>
private void deleteAliases(MemoryIndex targetIndex, IMemoryAlias targetAliases)
{
foreach (MemoryIndex aliasIndex in targetAliases.MustAliases)
{
MemoryAliasInfo aliasInfo = getAliasInfo(aliasIndex);
aliasInfo.AddRemovedAlias(targetIndex);
}
foreach (MemoryIndex aliasIndex in targetAliases.MayAliases)
{
MemoryAliasInfo aliasInfo = getAliasInfo(aliasIndex);
aliasInfo.AddRemovedAlias(targetIndex);
}
}
/// <inheritdoc />
public override void SetAlias(MemoryIndex index, IMemoryAlias alias)
{
IIndexDefinition data;
if (!indexDefinitions.TryGetValue(index, out data))
{
data = new CopyIndexDefinition();
}
IIndexDefinitionBuilder builder = data.Builder(this);
builder.SetAliases(alias);
indexDefinitions[index] = builder.Build(this);
}
/// <inheritdoc />
public override bool TryGetAliases(MemoryIndex index, out IMemoryAlias aliases)
{
IIndexDefinition data;
if (indexDefinitions.TryGetValue(index, out data))
{
aliases = data.Aliases;
return(data.Aliases != null);
}
else
{
aliases = null;
return(false);
}
}
/// <summary>
/// Collects the source aliases.
/// </summary>
/// <param name="sourceAliases">The source aliases.</param>
public void collectSourceAliases(IMemoryAlias sourceAliases)
{
// Collect source aliases
if (sourceAliases != null && sourceAliases.HasAliases)
{
references.CollectMust(sourceAliases.MustAliases);
references.CollectMay(sourceAliases.MayAliases);
hasAliases = true;
}
else
{
aliasesAlwaysDefined = false;
}
}
/// <inheritdoc />
public override void SetAlias(MemoryIndex index, IMemoryAlias alias)
{
IIndexDefinition data;
if (!indexDefinitions.TryGetValue(index, out data))
{
data = Factories.StructuralContainersFactories.IndexDefinitionFactory.CreateIndexDefinition(this);
}
IIndexDefinitionBuilder builder = data.Builder(this);
builder.SetAliases(alias);
indexDefinitions[index] = builder.Build(this);
changeTracker.ModifiedIndex(index);
}
private void processAliases(IMemoryAlias memoryAlias)
{
if (ProcessAliases)
{
// Assign new aliases if any
if (Node.HasAliases)
{
Worker.Snapshot.DestroyAliases(TargetIndex);
IEnumerable <MemoryIndex> mustAliases = Node.References.GetMustReferences();
List <MemoryIndex> filteredMustAliases = new List <MemoryIndex>();
foreach (MemoryIndex alias in mustAliases)
{
if (!alias.Equals(TargetIndex))
{
Worker.Snapshot.AddAlias(alias, TargetIndex, null);
filteredMustAliases.Add(alias);
}
}
IEnumerable <MemoryIndex> mayAliases = Node.References.GetMayReferences();
List <MemoryIndex> filteredMayAliases = new List <MemoryIndex>();
foreach (MemoryIndex alias in mayAliases)
{
if (!alias.Equals(TargetIndex))
{
Worker.Snapshot.AddAlias(alias, null, TargetIndex);
filteredMayAliases.Add(alias);
}
}
Worker.Snapshot.MustSetAliasesWithoutDelete(TargetIndex, filteredMustAliases, filteredMayAliases);
}
// Destroys old aliases if any
else if (memoryAlias != null && memoryAlias.HasAliases)
{
Worker.Snapshot.DestroyAliases(TargetIndex);
}
}
}
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);
}
}
}
private void processAliases(IMemoryAlias memoryAlias)
{
if (ProcessAliases)
{
if (Node.HasAliases || memoryAlias != null && memoryAlias.HasAliases)
{
HashSet <MemoryIndex> aliases = new HashSet <MemoryIndex>();
CollectionMemoryUtils.AddAll(aliases, Node.References.GetAllReferences());
if (memoryAlias != null && memoryAlias.HasAliases)
{
CollectionMemoryUtils.AddAll(aliases, memoryAlias.MustAliases);
CollectionMemoryUtils.AddAll(aliases, memoryAlias.MayAliases);
}
foreach (MemoryIndex alias in aliases)
{
Worker.Snapshot.AddAlias(alias, null, TargetIndex);
}
Worker.Snapshot.MaySetAliases(TargetIndex, aliases);
}
}
}
/// <inheritdoc />
public void SetAliases(IMemoryAlias aliases)
{
this.aliases = aliases;
}
/// <summary>
/// Initializes a new instance of the <see cref="CopyIndexDefinition"/> class.
/// </summary>
/// <param name="indexDefinition">The index definition.</param>
public CopyIndexDefinition(CopyIndexDefinition indexDefinition)
{
this.aliases = indexDefinition.aliases;
this.objects = indexDefinition.objects;
this.arrayValue = indexDefinition.arrayValue;
}
/// <inheritdoc /> public abstract void SetAlias(MemoryIndex index, IMemoryAlias alias);
/// <inheritdoc /> public abstract bool TryGetAliases(MemoryIndex index, out IMemoryAlias aliases);
