/// <summary> /// Creates the alias to this entry and returnes data which can be used to aliasing the target. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <returns> /// Alias data fro the newly created aliases. /// </returns> public AliasData CreateAliasToEntry(Snapshot snapshot) { //Collect alias indexes AssignCollector indexesCollector = new AssignCollector(snapshot); indexesCollector.ProcessPath(path); //Memory locations where to get data from ReadCollector valueCollector = new ReadCollector(snapshot); valueCollector.ProcessPath(path); //Get data from locations ReadWorker worker = new ReadWorker(snapshot); MemoryEntry value = worker.ReadValue(valueCollector); //Makes deep copy of data to prevent changes after assign alias TemporaryIndex temporaryIndex = snapshot.CreateTemporary(); MergeWithinSnapshotWorker mergeWorker = new MergeWithinSnapshotWorker(snapshot); mergeWorker.MergeMemoryEntry(temporaryIndex, value); AliasData data = new AliasData(indexesCollector.MustIndexes, indexesCollector.MayIndexes, temporaryIndex); data.TemporaryIndexToRealease(temporaryIndex); return(data); }
/// <summary> /// Determines whether this index is part of acces path of the other index. /// </summary> /// <param name="otherIndex">Index of the other.</param> /// <returns> /// True whether this index is prefix of the given one. /// </returns> internal override bool IsPrefixOf(MemoryIndex otherIndex) { TemporaryIndex tempIndex = otherIndex as TemporaryIndex; if (tempIndex != null) { return(rootId.Equals(tempIndex.rootId) && base.IsPrefixOf(otherIndex)); } else { return(false); } }
/// <summary> /// Determines whether the specified <see cref="System.Object" />, is equal to this instance. /// </summary> /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param> /// <returns> /// <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>. /// </returns> public override bool Equals(object obj) { TemporaryIndex otherIndex = obj as TemporaryIndex; if (otherIndex != null) { return(rootId.Equals(otherIndex.rootId) && base.Equals(obj)); } else { return(false); } }
/// <summary> /// Gets the snapshot entry of temporary index associated with this memory entry. /// </summary> /// <param name="context">The context.</param> private SnapshotEntry getTemporary(SnapshotBase context) { Snapshot snapshot = SnapshotEntry.ToSnapshot(context); if (temporaryLocation == null) { temporaryIndex = snapshot.CreateTemporary(); MergeWithinSnapshotWorker mergeWorker = new MergeWithinSnapshotWorker(snapshot); mergeWorker.MergeMemoryEntry(temporaryIndex, dataEntry); temporaryLocation = new SnapshotEntry(MemoryPath.MakePathTemporary(temporaryIndex)); } return(temporaryLocation); }
/// <summary> /// Writes the memory normal. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <param name="value">The value.</param> /// <param name="forceStrongWrite">if set to <c>true</c> [force strong write].</param> private void writeMemoryNormal(Snapshot snapshot, MemoryEntry value, bool forceStrongWrite) { TemporaryIndex temporaryIndex = snapshot.CreateTemporary(); MergeWithinSnapshotWorker mergeWorker = new MergeWithinSnapshotWorker(snapshot); mergeWorker.MergeMemoryEntry(temporaryIndex, value); AssignCollector collector = new AssignCollector(snapshot); collector.ProcessPath(path); if (forceStrongWrite) { collector.SetAllToMust(); } AssignWorker worker = new AssignWorker(snapshot); worker.Assign(collector, temporaryIndex); snapshot.ReleaseTemporary(temporaryIndex); }
/// <summary> /// Sets the temporary index which can be released using Release method. /// </summary> /// <param name="temporaryIndex">Temporary index to realease.</param> internal void TemporaryIndexToRealease(TemporaryIndex temporaryIndex) { this.temporaryIndex = temporaryIndex; }
/// <summary> /// Initializes a new instance of the <see cref="TemporaryPathSegment"/> class. /// </summary> /// <param name="temporaryIndex">Index of the temporary.</param> public TemporaryPathSegment(TemporaryIndex temporaryIndex) : base(true) { this.TemporaryIndex = temporaryIndex; }
/// <summary> /// Makes the path to temporary memory location. /// </summary> /// <param name="temporaryIndex">Index of the temporary.</param> /// <returns>New path to temporary memory location</returns> public static MemoryPath MakePathTemporary(TemporaryIndex temporaryIndex) { return(new MemoryPath(new TemporaryPathSegment(temporaryIndex), GlobalContext.LocalOnly, temporaryIndex.CallLevel)); }
/// <summary> /// Initializes a new instance of the <see cref="TemporaryIndex"/> class. /// </summary> /// <param name="parentIndex">Index of the parent.</param> /// <param name="callLevel">The call level.</param> public TemporaryIndex(TemporaryIndex parentIndex, int callLevel) : base(parentIndex.MemoryPath, callLevel) { rootId = parentIndex.rootId; }
/// <summary> /// Initializes a new instance of the <see cref="TemporaryIndex"/> class. /// </summary> /// <param name="parentIndex">Index of the parent.</param> /// <param name="path">The path.</param> public TemporaryIndex(TemporaryIndex parentIndex, List <IndexSegment> path) : base(path, parentIndex.CallLevel) { rootId = parentIndex.rootId; }
/// <summary> /// Initializes a new instance of the <see cref="TemporaryIndex"/> class. /// </summary> /// <param name="parentIndex">Index of the parent.</param> /// <param name="pathName">Name of the path.</param> public TemporaryIndex(TemporaryIndex parentIndex, IndexSegment pathName) : base(parentIndex, pathName) { rootId = parentIndex.rootId; }