/// <inheritdoc />
public void AssignAlias(Snapshot snapshot, MemoryPath targetPath, MemoryPath sourcePath)
{
if (snapshot.AssignInfo == null)
{
snapshot.AssignInfo = new AssignInfo();
}
// Collects memory location of alias sources
TreeIndexCollector aliasSourcesCollector = new TreeIndexCollector(snapshot);
aliasSourcesCollector.ProcessPath(sourcePath);
// Creates missing source locations and collect source data
AliasWorker aliasWorker = new AliasWorker(Factories, snapshot, aliasSourcesCollector, snapshot.AssignInfo.AliasAssignModifications);
aliasWorker.CollectAliases();
// Collects target locations
TreeIndexCollector aliasTargetCollector = new TreeIndexCollector(snapshot);
aliasTargetCollector.ProcessPath(targetPath);
// Creates missing target locations, create aliases and assign source data
AssignWorker assignWorker = new AssignWorker(Factories, snapshot, aliasWorker.EntryCollector, aliasTargetCollector, snapshot.AssignInfo.AliasAssignModifications);
assignWorker.AssignAliasesIntoCollectedIndexes = true;
assignWorker.Assign();
}
/// <summary>
/// Process given access path and collects all matching indexes. This is an entry point
/// of the computation.
/// </summary>
/// <param name="path">The path.</param>
public void ProcessPath(MemoryPath path)
{
currentPath = path;
foreach (var segment in path.PathSegments)
{
processAliases();
var swap = currentNodes;
currentNodes = nextIterationNodes;
nextIterationNodes = swap;
nextIterationNodes.Clear();
segment.Accept(this);
}
if (PostProcessAliases)
{
processAliases();
}
currentNodes = nextIterationNodes;
foreach (CollectorNode node in currentNodes)
{
node.IsCollected = true;
}
}
/// <inheritdoc />
public void Assign(Snapshot snapshot, MemoryPath path, MemoryEntry value, bool forceStrongWrite)
{
if (snapshot.AssignInfo == null)
{
snapshot.AssignInfo = new AssignInfo();
}
MemoryIndexModificationList pathModifications = snapshot.AssignInfo.GetOrCreatePathModification(path);
// Collecting all sources of the data
MemoryEntryCollector entryCollector = new MemoryEntryCollector(snapshot);
entryCollector.ProcessRootMemoryEntry(value);
// Collecting all locations where to assign into
TreeIndexCollector treeCollector = new TreeIndexCollector(snapshot);
treeCollector.PostProcessAliases = true;
treeCollector.ProcessPath(path);
// Provides an assign operation
AssignWorker worker = new AssignWorker(Factories, snapshot, entryCollector, treeCollector, pathModifications);
worker.ForceStrongWrite = forceStrongWrite;
worker.Assign();
}
/// <inheritdoc />
public bool IsDefined(Snapshot snapshot, MemoryPath path)
{
ReadCollector collector = new ReadCollector(snapshot);
collector.ProcessPath(path);
return(collector.IsDefined);
}
/// <inheritdoc />
public MemoryEntry Read(Snapshot snapshot, MemoryPath path)
{
ReadCollector collector = new ReadCollector(snapshot);
collector.ProcessPath(path);
ReadWorker worker = new ReadWorker(snapshot);
return(worker.ReadValue(collector));
}
/// <inheritdoc />
public void WriteWithoutCopy(Snapshot snapshot, MemoryPath path, MemoryEntry value)
{
AssignCollector collector = new AssignCollector(snapshot);
collector.ProcessPath(path);
Weverca.MemoryModels.ModularCopyMemoryModel.Implementation.Algorithm.CopyAlgorithms.MemoryWorkers.AssignWithoutCopyWorker worker
= new Weverca.MemoryModels.ModularCopyMemoryModel.Implementation.Algorithm.CopyAlgorithms.MemoryWorkers.AssignWithoutCopyWorker(Factories, snapshot);
worker.Assign(collector, value);
}
/// <summary>
/// Processes the given access path.
/// </summary>
/// <param name="path">The path.</param>
public void ProcessPath(MemoryPath path)
{
Global = path.Global;
CallLevel = path.CallLevel;
foreach (PathSegment segment in path.PathSegments)
{
Next(segment);
}
FinishPath();
}
private bool IsTestCasePresentInFilesOrMemoryTree()
{
MemoryPath = TestCasesListOperations.IsPresentInTheTestCasesTree(ContentName.Text,
FilesAndFolderStructure.ConcatFileNameToFolder(OutputFile.Text, FolderType.Tests),
null);
if (!MemoryPath.Equals(""))
{
ContentName.ForeColor = Color.Red;
return(true);
}
return(false);
}
private bool IsTestCasePresentInFilesOrMemoryTree()
{
MemoryPath = TestCasesListOperations.IsPresentInTheTestCasesTree(TestCaseName.Text,
FilesAndFolderStructure.ConcatFileNameToFolder(OutputFile.Text, FolderType.Tests),
RobotAutomationHelper.TestCases[ImplementationIndexFromTheParent]);
if (!MemoryPath.Equals(""))
{
TestCaseName.ForeColor = Color.Red;
return(true);
}
return(false);
}
private bool IsKeywordPresentInFilesOrMemoryTree()
{
MemoryPath = TestCasesListOperations.IsPresentInTheKeywordTree(KeywordName.Text,
FilesAndFolderStructure.ConcatFileNameToFolder(OutputFile.Text, FolderType.Resources),
_parentKeywords[ImplementationIndexFromTheParent]);
if (MemoryPath.Equals(""))
{
return(false);
}
KeywordName.ForeColor = Color.DarkOrange;
return(true);
}
/// <summary>
/// Creates the snapshot entry for the given variable name.
/// </summary>
/// <param name="variable">The variable name.</param>
/// <param name="global">Determines whether variable is global or local.</param>
/// <param name="callLevel">The call level.</param>
internal static ReadWriteSnapshotEntryBase CreateVariableEntry(AnalysisFramework.VariableIdentifier variable, GlobalContext global, int callLevel)
{
MemoryPath path;
if (variable.IsUnknown)
{
path = MemoryPath.MakePathAnyVariable(global, callLevel);
}
else
{
var names = from name in variable.PossibleNames select name.Value;
path = MemoryPath.MakePathVariable(names, global, callLevel);
}
return(new SnapshotEntry(path, variable));
}
/// <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();
temporaryLocation = new SnapshotEntry(MemoryPath.MakePathTemporary(temporaryIndex));
snapshot.Factories.Benchmark.StartAlgorithm(snapshot, AlgorithmType.MERGE_TO_TEMPORARY);
snapshot.Algorithms.MergeAlgorithm.MergeMemoryEntry(snapshot, temporaryIndex, dataEntry);
snapshot.Factories.Benchmark.FinishAlgorithm(snapshot, AlgorithmType.MERGE_TO_TEMPORARY);
}
return(temporaryLocation);
}
/// <summary>
/// Read memory represented by given field identifier resolved on current
/// snapshot entry (resulting snapshot entry can encapsulate merging, alias resolving and
/// other stuff based on nondeterminism of identifier and current snapshot entry)
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="field">Identifier of an field</param>
/// <returns>
/// Snapshot entry representing field resolving on current entry
/// </returns>
protected override ReadWriteSnapshotEntryBase readField(SnapshotBase context, AnalysisFramework.VariableIdentifier field)
{
MemoryPath newPath;
if (field.IsUnknown)
{
newPath = MemoryPath.MakePathAnyField(path);
}
else
{
var names = from name in field.PossibleNames select name.Value;
newPath = MemoryPath.MakePathField(path, names);
}
return(new SnapshotEntry(newPath, variableId));
}
/// <inheritdoc />
public void Assign(Snapshot snapshot, MemoryPath path, MemoryEntry value, bool forceStrongWrite)
{
if (snapshot.AssignInfo == null)
{
snapshot.AssignInfo = new AssignInfo();
}
MemoryIndexModificationList pathModifications = snapshot.AssignInfo.GetOrCreatePathModification(path);
List <Tuple <MemoryIndex, HashSet <Value> > > valuesToAssign = new List <Tuple <MemoryIndex, HashSet <Value> > >();
// Prepares locations and values to assign
foreach (var item in pathModifications.Modifications)
{
MemoryIndex index = item.Key;
MemoryIndexModification indexModification = item.Value;
HashSet <Value> values = new HashSet <Value>();
valuesToAssign.Add(new Tuple <MemoryIndex, HashSet <Value> >(index, values));
if (indexModification.IsCollectedIndex)
{
CollectionMemoryUtils.AddAll(values, value.PossibleValues);
}
// Loads all other datasources where to get additional values to assign - unknown indexes.
foreach (var datasource in indexModification.Datasources)
{
MemoryEntry entry;
if (datasource.SourceSnapshot.Infos.Readonly.TryGetMemoryEntry(datasource.SourceIndex, out entry))
{
CollectionMemoryUtils.AddAll(values, entry.PossibleValues);
}
}
}
// Assigns values to locations
foreach (var item in valuesToAssign)
{
MemoryIndex index = item.Item1;
HashSet <Value> values = item.Item2;
MemoryEntry entry = new MemoryEntry(values);
snapshot.Infos.Writeable.SetMemoryEntry(index, entry);
}
}
/// <summary>
/// Read memory represented by given index identifier resolved on current
/// snapshot entry (resulting snapshot entry can encapsulate merging, alias resolving and
/// other stuff based on nondeterminism of identifier and current snapshot entry)
/// </summary>
/// <param name="context">Context snapshot where operation is proceeded</param>
/// <param name="index">Identifier of an index</param>
/// <returns>
/// Snapshot entry representing index resolving on current entry
/// </returns>
protected override ReadWriteSnapshotEntryBase readIndex(SnapshotBase context, MemberIdentifier index)
{
MemoryPath newPath;
if (index.IsAny)
{
newPath = MemoryPath.MakePathAnyIndex(path);
}
else if (index.IsUnknown)
{
newPath = MemoryPath.MakePathUnknownIndex(path);
}
else
{
newPath = MemoryPath.MakePathIndex(path, index.PossibleNames);
}
return(new SnapshotEntry(newPath, variableId));
}
void Start()
{
script = gameObject.transform.parent.GetComponent <MemoryPath>();
color = gameObject.GetComponent <ObjectColor>();
}
/// <summary>
/// Initializes a new instance of the <see cref="SnapshotEntry"/> class.
/// </summary>
/// <param name="path">The variable acces path.</param>
/// <param name="variableId">The variable unique identifier.</param>
private SnapshotEntry(MemoryPath path, AnalysisFramework.VariableIdentifier variableId)
{
this.path = path;
this.variableId = variableId;
}
/// <summary>
/// Initializes a new instance of the <see cref="SnapshotEntry"/> class.
/// </summary>
/// <param name="path">The variable acces path.</param>
internal SnapshotEntry(MemoryPath path)
{
this.path = path;
this.variableId = null;
}
/// <summary>
/// Creates the snapshot entry for the given variable name.
/// </summary>
/// <param name="name">The name of control variable.</param>
/// <param name="global">Determines whether variable is global or local.</param>
/// <param name="callLevel">The call level.</param>
/// <returns>New snapshot entry for the given variable name.</returns>
internal static ReadWriteSnapshotEntryBase CreateControlEntry(VariableName name, GlobalContext global, int callLevel)
{
MemoryPath path = MemoryPath.MakePathControl(new string[] { name.ToString() }, global, callLevel);
return(new SnapshotEntry(path));
}
/// <inheritdoc />
public void AssignAlias(Snapshot snapshot, MemoryPath targetPath, MemoryPath sourcePath)
{
// Do nothing - Alias cannot be assigned in info mode
}
