private static int ResourceNameComparer(IOldToNewTupleMap <GeneratedProjectOutputInfo> generationProjectInfoMap, string oldName, string newName)
{
var isOldNameEmpty = string.IsNullOrWhiteSpace(oldName);
var isNewNameEmpty = string.IsNullOrWhiteSpace(newName);
if (!isOldNameEmpty && !isNewNameEmpty)
{
oldName = generationProjectInfoMap.OldType.GetRelativePath(oldName);
newName = generationProjectInfoMap.NewType.GetRelativePath(newName);
return(string.Compare(oldName, newName, true));
}
if (isOldNameEmpty && isNewNameEmpty)
{
return(0);
}
if (isOldNameEmpty && !isNewNameEmpty)
{
return(1);
}
return(-1);
}
public AssemblyNode(IOldToNewTupleMap <string> map, IReadOnlyList <ModuleNode> modules, IReadOnlyList <ResourceNode> resources)
: base("", map.GetFirstNotNullItem())
{
Map = map;
Modules = modules;
Resources = resources;
}
public AssemblyBrowseTabItem(IOldToNewTupleMap <string> comparableModel)
{
APIDiffInfo diffInfo = new APIDiffInfo(APIDiffHelper.GetAPIDifferences(comparableModel.OldType, comparableModel.NewType));
var generationProjectInfoMap = new OldToNewTupleMap <GeneratedProjectOutputInfo>
(
new GeneratedProjectOutputInfo(comparableModel.OldType),
new GeneratedProjectOutputInfo(comparableModel.NewType)
);
FilterSettings filterSettings = new FilterSettings(this.ShowAllUnmodified);
this.nodes = new AssemblyNode[] {
new AssemblyNode(comparableModel, null, null, this, filterSettings)
{
GenerationProjectInfoMap = generationProjectInfoMap
}
};
this.header = GetTabTitle(comparableModel);
this.toolTip = GetTabToolTip(comparableModel);
this.nodes[0].ChildrenLoaded += OnAssemblyNodeChildrenLoaded;
this.contentLoaded = new bool[2];
}
public AssemblyNode CreateAssemblyNode(IOldToNewTupleMap <string> assemblyMap)
{
var generationProjectInfoMap = new OldToNewTupleMap <GeneratedProjectOutputInfo>
(
new GeneratedProjectOutputInfo(assemblyMap.OldType),
new GeneratedProjectOutputInfo(assemblyMap.NewType)
);
Console.Write("Loading old assembly...");
var assemblyDecompilationResultOld = GetAssemblyDecompilationResult(
assemblyMap.OldType,
generationProjectInfoMap.OldType.OutputPath,
CancellationToken.None);
GlobalDecompilationResultsRepository.Instance.AddDecompilationResult(assemblyMap.OldType, assemblyDecompilationResultOld);
Console.WriteLine("done.");
Console.Write("Loading new assembly...");
var assemblyDecompilationResultNew = GetAssemblyDecompilationResult(
assemblyMap.NewType,
generationProjectInfoMap.NewType.OutputPath,
CancellationToken.None);
GlobalDecompilationResultsRepository.Instance.AddDecompilationResult(assemblyMap.NewType, assemblyDecompilationResultNew);
Console.WriteLine("done.");
return(AssemblyNode.Create(assemblyMap, generationProjectInfoMap));
}
public ModuleNode(AssemblyNode parent, IOldToNewTupleMap <ModuleMetadata> map, IReadOnlyList <NamespaceNode> namespaces)
: base(parent, "", map.GetFirstNotNullItem().GetName())
{
Parent = parent;
Map = map;
Namespaces = namespaces;
}
public ResourceMergeManager(IOldToNewTupleMap <ICollection <string> > resourcesMap, Comparison <string> oldResourceNameComparer, Comparison <string> newResourceNameComparer,
Comparison <string> resourceNameComparer)
: base(resourcesMap)
{
this.oldResourceNameComparer = oldResourceNameComparer;
this.newResourceNameComparer = newResourceNameComparer;
this.resourceNameComparer = resourceNameComparer;
}
public DefaultResourceNode(IOldToNewTupleMap <string> typesMap, ItemNodeBase parent, IOldToNewTupleMap <GeneratedProjectOutputInfo> generationProjectInfoMap, FilterSettings filterSettings)
: base("Resources", parent, filterSettings)
{
this.typesMap = typesMap;
this.GenerationProjectInfoMap = generationProjectInfoMap;
this.IsExpanded = true;
}
private FolderNode ProcessFolderNodeCreation(IOldToNewTupleMap <string> typesMap)
{
APIDiffInfo diffInfo = this.apiDiffInfo == null ? null : new APIDiffInfo(null);
var folderNode = new FolderNode(typesMap, this, diffInfo, progressNotifier, this.FilterSettings, false);
return(folderNode);
}
public ModuleNode(IOldToNewTupleMap <ModuleMetadata> modulesMap, ItemNodeBase parent, APIDiffInfo apiDiffInfo, bool shouldBeExpanded, FilterSettings filterSettings)
: base(GetName(modulesMap), parent, apiDiffInfo, filterSettings)
{
this.ModulesMap = modulesMap;
this.differenceDecoration = GetDifferenceDecoration();
this.IsExpanded = shouldBeExpanded;
}
public AssemblyNode(IOldToNewTupleMap <string> typesMap, ItemNodeBase parent, APIDiffInfo apiDiffInfo, IProgressNotifier progressNotifier, FilterSettings filterSettings)
: base(Path.GetFileName(typesMap.GetFirstNotNullItem()), parent, apiDiffInfo, filterSettings)
{
this.TypesMap = typesMap;
this.progressNotifier = progressNotifier;
this.areChildrenLoaded = false;
}
public MemberNode(IOldToNewTupleMap <MemberMetadata> membersMap, ItemNodeBase parent, APIDiffInfo apiDiffInfo, FilterSettings filterSettings)
: base(membersMap.GetFirstNotNullItem().GetSignature(), parent, apiDiffInfo, filterSettings)
{
this.membersMap = membersMap;
this.differenceDecoration = GetDifferenceDecoration();
// This node has no child items, so this removes the expander.
this.LazyLoading = false;
}
public ResourceNode(IOldToNewTupleMap <string> resourceMap, ItemNodeBase parent, FilterSettings filterSettings)
: base(GetResourceName(resourceMap.GetFirstNotNullItem()), parent, filterSettings)
{
this.ResourceMap = resourceMap;
this.differenceDecoration = GetDifferenceDecoration();
// This node has no child items, so this removes the expander.
this.LazyLoading = false;
}
public TypeNode(
TypeNode parent,
IOldToNewTupleMap <TypeMetadata> map,
IReadOnlyList <MemberNodeBase> members)
: base(parent, map)
{
Parent = parent;
Map = map;
Members = members;
}
public XamlResourceNode(IOldToNewTupleMap <string> resourceMap, string name, ItemNodeBase parent, FilterSettings filterSettings)
: base(name, parent, null, filterSettings)
{
this.ResourceMap = resourceMap;
this.differenceDecoration = this.GetDifferenceDecoration();
// This node has no child items, so this removes the expander.
this.LazyLoading = false;
}
protected MemberNodeBase(
NamespaceNode parent,
IOldToNewTupleMap <MemberDefinitionMetadataBase> map,
IDecompilationResults oldDecompileResult,
IDecompilationResults newDecompileResult)
: base(parent, parent.Namespace, map.GetFirstNotNullItem().GetName())
{
Map = map;
OldDecompileResult = oldDecompileResult;
NewDecompileResult = newDecompileResult;
}
public FolderBrowseTabItem(IOldToNewTupleMap <string> tupleMap)
{
FilterSettings filterSettings = new FilterSettings(this.ShowAllUnmodified);
this.nodes = new ItemNodeBase[] {
new FolderNode(tupleMap, null, null, this, filterSettings, true)
};
this.header = GetTabTitle(tupleMap);
this.toolTip = GetTabToolTip(tupleMap);
}
private string GetResourceName(IOldToNewTupleMap <string> resourceMap)
{
if (resourceMap.OldType != null)
{
return(this.GenerationProjectInfoMap.OldType.GetRelativePath(resourceMap.OldType));
}
else
{
return(this.GenerationProjectInfoMap.NewType.GetRelativePath(resourceMap.NewType));
}
}
protected MemberNodeBase(NestedTypeNode parent, IOldToNewTupleMap <MemberDefinitionMetadataBase> map)
: base(parent, parent.GetNamespaceIncludingName(), map.GetFirstNotNullItem().GetName())
{
Map = map;
if (parent != null)
{
OldDecompileResult = parent.OldDecompileResult;
NewDecompileResult = parent.NewDecompileResult;
}
}
public FolderNode(IOldToNewTupleMap <string> folderMap, ItemNodeBase parent, APIDiffInfo apiDiffInfo, IProgressNotifier progressNotifier, FilterSettings filterSettings, bool loadChildrenAsync)
: base(GetName(folderMap), parent, apiDiffInfo, filterSettings)
{
this.folderMap = folderMap;
this.progressNotifier = progressNotifier;
// This line needs to be before this.IsExpanded = true; in any case.
this.loadChildrenAsync = loadChildrenAsync;
this.IsExpanded = true;
}
public TypeNode(
NamespaceNode parent,
IOldToNewTupleMap <TypeMetadata> map,
IReadOnlyList <MemberNodeBase> members,
IDecompilationResults oldDecompileResult,
IDecompilationResults newDecompileResult)
: base(parent, map, oldDecompileResult, newDecompileResult)
{
Parent = parent;
Map = map;
Members = members;
}
public static TypeNode Create(NamespaceNode parent, IOldToNewTupleMap <TypeMetadata> map)
{
var oldTypeMetadata = map.OldType;
var newTypeMetadata = map.NewType;
IDecompilationResults oldResult = null;
IDecompilationResults newResult = null;
IDecompilationResults result;
if (oldTypeMetadata != null &&
GlobalDecompilationResultsRepository.Instance.TryGetDecompilationResult(
oldTypeMetadata.AssemblyPath,
oldTypeMetadata.Module.TokenId,
oldTypeMetadata.TokenId,
out result))
{
oldResult = result;
}
if (newTypeMetadata != null &&
GlobalDecompilationResultsRepository.Instance.TryGetDecompilationResult(
newTypeMetadata.AssemblyPath,
newTypeMetadata.Module.TokenId,
newTypeMetadata.TokenId,
out result))
{
newResult = result;
}
var typeNode = new TypeNode(parent, map, new MemberNodeBase[0], oldResult, newResult);
var memberManager = new MemberMergeManager(map);
var members = memberManager.GetMergedCollection().Select <IOldToNewTupleMap <MemberDefinitionMetadataBase>, MemberNodeBase> (
e =>
{
if (e.GetFirstNotNullItem().MemberType == MemberType.Type)
{
return(NestedTypeNode.Create(
typeNode,
new OldToNewTupleMap <TypeMetadata> ((TypeMetadata)e.OldType, (TypeMetadata)e.NewType)));
}
return(new MemberNode(
typeNode,
new OldToNewTupleMap <MemberMetadata> ((MemberMetadata)e.OldType, (MemberMetadata)e.NewType)));
}).ToArray();
typeNode.Members = members;
return(typeNode);
}
private ItemNodeBase GetResourceNode(IOldToNewTupleMap <string> resourceMap)
{
string resourceFile = Path.GetExtension(resourceMap.GetFirstNotNullItem()).ToLower();
switch (resourceFile)
{
case ".xaml":
return(new XamlResourceNode(resourceMap, GetResourceName(resourceMap), this, this.FilterSettings));
default:
return(new ResourceNode(resourceMap, this, this.FilterSettings));
}
}
private DecompiledMemberNodeBase GetItemNodeFromMemberType(IOldToNewTupleMap <MemberDefinitionMetadataBase> membersMap, LoadAPIItemsContext context)
{
MemberDefinitionMetadataBase metadata = membersMap.GetFirstNotNullItem();
APIDiffInfo diffInfo = context.GenerateAPIDiffInfo(membersMap);
if (metadata.MemberType == MemberType.Type)
{
return(new NestedTypeNode((new OldToNewTupleMap <TypeMetadata>((TypeMetadata)membersMap.OldType, (TypeMetadata)membersMap.NewType)), this, diffInfo, this.FilterSettings));
}
else
{
return(new MemberNode((new OldToNewTupleMap <MemberMetadata>((MemberMetadata)membersMap.OldType, (MemberMetadata)membersMap.NewType)), this, diffInfo, this.FilterSettings));
}
}
public IMetadataDiffItem GetDiffItem(IOldToNewTupleMap <MemberMetadataBase> tuple)
{
IMetadataDiffItem oldDiffItem = null;
IMetadataDiffItem newDiffItem = null;
if (tuple.OldType == null && tuple.NewType == null)
{
throw new ArgumentException();
}
if (tuple.OldType != null)
{
if (!oldChildrenTokens.TryGetValue(tuple.OldType.TokenId, out oldDiffItem))
{
oldDiffItem = null;
}
else
{
oldChildrenTokens.Remove(tuple.OldType.TokenId);
}
}
if (tuple.NewType != null)
{
if (!newChildrenTokens.TryGetValue(tuple.NewType.TokenId, out newDiffItem))
{
newDiffItem = null;
}
else
{
newChildrenTokens.Remove(tuple.NewType.TokenId);
}
}
if (oldDiffItem != null && newDiffItem != null && oldDiffItem != newDiffItem)
{
throw new Exception("Diff item mismatch");
}
if (oldDiffItem == null && newDiffItem == null)
{
;
}
return(oldDiffItem ?? newDiffItem);
}
public static ModuleNode CreateFromModuleMap(AssemblyNode parent, IOldToNewTupleMap <ModuleMetadata> moduleMap)
{
var module = new ModuleNode(parent, moduleMap, new NamespaceNode[0]);
var types = new TypesMergeManager(moduleMap)
.GetMergedCollection()
.ToList();
var namespaces = types.GroupBy(e => e.GetFirstNotNullItem().GetNamespace())
.OrderBy(e => e.Key)
.Select(e => NamespaceNode.Create(module, e.Key, e.ToArray()))
.ToArray();
module.Namespaces = namespaces;
return(module);
}
protected string GetTabToolTip(IOldToNewTupleMap <string> comparableModel)
{
string oldItemName = string.Empty;
string newItemName = string.Empty;
if (comparableModel.OldType != null)
{
var oldDirInfo = new DirectoryInfo(comparableModel.OldType);
oldItemName = oldDirInfo.FullName;
}
if (comparableModel.NewType != null)
{
var newDirInfo = new DirectoryInfo(comparableModel.NewType);
newItemName = newDirInfo.FullName;
}
return(string.Format("{0} <> {1}", oldItemName, newItemName));
}
private AssemblyNode ProcessAssemblyNodeCreation(IOldToNewTupleMap <string> typesMap)
{
APIDiffInfo diffInfo = this.apiDiffInfo != null ? new APIDiffInfo(APIDiffHelper.GetAPIDifferences(typesMap.OldType, typesMap.NewType)) : null;
var generationProjectInfoMap = new OldToNewTupleMap <GeneratedProjectOutputInfo>
(
new GeneratedProjectOutputInfo(typesMap.OldType),
new GeneratedProjectOutputInfo(typesMap.NewType)
);
var assemblyNode = new AssemblyNode(typesMap, this, diffInfo, progressNotifier, this.FilterSettings)
{
GenerationProjectInfoMap = generationProjectInfoMap
};
assemblyNode.SetDifferenceDecoration();
return(assemblyNode);
}
public int GetAssembliesCount(IOldToNewTupleMap <string> folderMap)
{
int result = 0;
string root = folderMap.OldType;
foreach (var extension in supportedFileExtensions)
{
result += Directory.GetFiles(root, "*" + extension, SearchOption.AllDirectories).Length;
}
root = folderMap.NewType;
foreach (var extension in supportedFileExtensions)
{
result += Directory.GetFiles(root, "*" + extension, SearchOption.AllDirectories).Length;
}
return(result);
}
public static AssemblyNode Create(IOldToNewTupleMap <string> assemblyMap, IOldToNewTupleMap <GeneratedProjectOutputInfo> generationProjectInfoMap)
{
var assemblyNode = new AssemblyNode(assemblyMap, new ModuleNode[0], new ResourceNode[0]);
var moduleMergeManager = new ModuleManager(assemblyMap);
var modulesNodes = moduleMergeManager.GetMergedCollection()
.Select(tuple => ModuleNode.CreateFromModuleMap(assemblyNode, tuple))
.ToArray();
assemblyNode.Modules = modulesNodes;
ICollection <string> oldResources = new Collection <string>();
ICollection <string> newResources = new Collection <string>();
IAssemblyDecompilationResults oldAssemblyResult;
IAssemblyDecompilationResults newAssemblyResult;
if (GlobalDecompilationResultsRepository.Instance.TryGetAssemblyDecompilationResult(assemblyMap.OldType, out oldAssemblyResult))
{
oldResources = oldAssemblyResult.ResourcesFilePaths;
}
if (GlobalDecompilationResultsRepository.Instance.TryGetAssemblyDecompilationResult(assemblyMap.NewType, out newAssemblyResult))
{
newResources = newAssemblyResult.ResourcesFilePaths;
}
var resourceMergeManager = new ResourceMergeManager(
new OldToNewTupleMap <ICollection <string> > (oldResources, newResources),
(a, b) => string.Compare(generationProjectInfoMap.OldType.GetRelativePath(a), generationProjectInfoMap.OldType.GetRelativePath(b), true),
(a, b) => string.Compare(generationProjectInfoMap.NewType.GetRelativePath(a), generationProjectInfoMap.NewType.GetRelativePath(b), true),
(a, b) => ResourceNameComparer(generationProjectInfoMap, a, b));
var resourceNodes = resourceMergeManager.GetMergedCollection()
.Select(e => new ResourceNode(assemblyNode, e))
.ToArray();
assemblyNode.Resources = resourceNodes;
return(assemblyNode);
}
public static NestedTypeNode Create(TypeNode parent, IOldToNewTupleMap <TypeMetadata> map)
{
var nestedTypeNode = new NestedTypeNode(parent, map, new MemberNodeBase[0]);
var memberManager = new MemberMergeManager(map);
var members = memberManager.GetMergedCollection().Select <IOldToNewTupleMap <MemberDefinitionMetadataBase>, MemberNodeBase> (
e =>
{
if (e.GetFirstNotNullItem().MemberType == MemberType.Type)
{
return(Create(
parent,
new OldToNewTupleMap <TypeMetadata> ((TypeMetadata)e.OldType, (TypeMetadata)e.NewType)));
}
return(new MemberNode(
nestedTypeNode,
new OldToNewTupleMap <MemberMetadata> ((MemberMetadata)e.OldType, (MemberMetadata)e.NewType)));
}).ToArray();
nestedTypeNode.Members = members;
return(nestedTypeNode);
}
