private string GetActualPath(string oldNodePath)
{
Node actualNode;
return(TemporaryRenames.TryGetValue(oldNodePath, out actualNode)
? actualNode.Path : oldNodePath);
}
private void UpdateHints()
{
var originalHints = Hints;
Hints = new HintSet(CurrentModel, TargetModel);
// Process RenameHints
foreach (var renameHint in originalHints.OfType <RenameHint>())
{
if (TemporaryRenames.TryGetValue(renameHint.SourcePath, out var sourceNode))
{
Hints.Add(new RenameHint(sourceNode.Path, renameHint.TargetPath));
}
else
{
Hints.Add(renameHint);
}
}
// Process CopyDataHints
foreach (var copyDataHint in originalHints.OfType <CopyDataHint>())
{
var sourceTablePath = GetActualPath(copyDataHint.SourceTablePath);
var identities = copyDataHint.Identities.Select(pair =>
new IdentityPair(GetActualPath(pair.Source), pair.Target, pair.IsIdentifiedByConstant))
.ToList();
var copiedColumns = copyDataHint.CopiedColumns.Select(pair =>
new Pair <string>(GetActualPath(pair.First), pair.Second))
.ToList();
var newCopyDataHint = new CopyDataHint(sourceTablePath, identities, copiedColumns);
Hints.Add(newCopyDataHint);
}
// Process DeleteDataHints
foreach (var deleteDataHint in originalHints.OfType <DeleteDataHint>())
{
if (!deleteDataHint.PostCopy)
{
continue; // It's not necessary to copy this hint
}
var sourceTablePath = GetActualPath(deleteDataHint.SourceTablePath);
var identities = deleteDataHint.Identities.Select(pair =>
new IdentityPair(GetActualPath(pair.Source), pair.Target, pair.IsIdentifiedByConstant))
.ToList();
var newDeleteDataHint = new DeleteDataHint(sourceTablePath, identities, true);
Hints.Add(newDeleteDataHint);
}
// Process IgnoreHints
foreach (var ignoreHint in originalHints.OfType <IgnoreHint>())
{
Hints.Add(ignoreHint);
}
}
/// <summary>
/// Registers the temporary rename.
/// </summary>
/// <param name="source">The renamed node.</param>
protected void RegisterTemporaryRename(Node source)
{
TemporaryRenames.Add(source.Path, CurrentModel.Resolve(source.Path, true) as Node);
var children = source.PropertyAccessors.Values
.Where(pa => !pa.IsImmutable).Select(pa => pa.Getter.Invoke(source));
foreach (var child in children)
{
var childNode = child as Node;
if (childNode != null)
{
if (!TemporaryRenames.ContainsKey(childNode.Path))
{
var currentModelChildNode = CurrentModel.Resolve(childNode.Path) as Node;
if (currentModelChildNode != null)
{
TemporaryRenames.Add(childNode.Path, currentModelChildNode);
}
}
continue;
}
var childNodeCollection = child as NodeCollection;
if (childNodeCollection != null)
{
foreach (Node node in childNodeCollection)
{
if (!TemporaryRenames.ContainsKey(node.Path))
{
var currentModelChildNode = CurrentModel.Resolve(node.Path) as Node;
if (currentModelChildNode != null)
{
TemporaryRenames.Add(node.Path, currentModelChildNode);
}
}
}
}
}
}
private string GetActualPath(string oldNodePath) => TemporaryRenames.TryGetValue(oldNodePath, out var actualNode) ? actualNode.Path : oldNodePath;
