//=====================================================================
/// <summary>
/// This is called to visit all namespaces, types, and members in the list of assemblies to be documented
/// </summary>
public void VisitApis()
{
// Store types. We have to do this after all assemblies are registered because the resolution may
// not work unless all the assemblies we need are in the resolver cache.
foreach (AssemblyNode assembly in assemblies)
{
this.StoreTypes(assembly.Types);
if (this.Canceled)
{
break;
}
}
if (!this.Canceled)
{
NamespaceList spaces = new NamespaceList();
foreach (Namespace space in catalog.Values)
{
if (filter.IsExposedNamespace(space))
{
spaces.Add(space);
}
}
if (!this.Canceled)
{
this.VisitNamespaces(spaces);
}
}
}
// Visit Object Model
public void VisitApis()
{
// store types
// we have to do this after all assemblies are registered because the resolution may not work unless
// all the assemblies we need are in the resolver cache
//Console.WriteLine("storing types");
foreach (AssemblyNode assembly in assemblies)
{
//Console.WriteLine("assembly {0}", assembly.Name);
//Console.WriteLine("has {0} types", assembly.Types.Count);
StoreTypes(assembly.Types);
//Console.WriteLine("done with assembly");
}
//Console.WriteLine("done storing types");
//Console.WriteLine("visiting namespaces");
NamespaceList spaces = new NamespaceList();
foreach (Namespace space in catalog.Values)
{
if (filter.IsExposedNamespace(space))
{
spaces.Add(space);
}
}
VisitNamespaces(spaces);
}
public static void init( )
{
// if ( allNamespaces != null ) return;
allNamespaces = new NamespaceList();
nsCached = new Dictionary <string, TypeNodeList>();
// Scan all assemblies referenced in parameters
// and take all namespaces from them.
// Put all these namespaces into the common list.
System.Collections.Specialized.StringCollection assemblies = CONTEXT.options.ReferencedAssemblies;
foreach (string assName in assemblies)
{
AssemblyNode assembly = AssemblyNode.GetAssembly(assName, true, false, true);
if (assembly == null && !CONTEXT.AnalysisOnly)
{
ERROR.UnresolvedReference(assName);
continue;
}
NamespaceList nss = assembly.GetNamespaceList();
for (int i = 0, n = nss.Length; i < n; i++)
{
allNamespaces.Add(nss[i]);
}
}
}
/// <summary>
/// Fetches the name space list object.
/// </summary>
/// <param name="pluginSource">The plugin source.</param>
/// <returns></returns>
public NamespaceList FetchNamespaceListObject(ComPluginSource pluginSource)
{
var interrogatePlugin = ReadNamespaces(pluginSource.ClsId, pluginSource.Is32Bit);
var namespacelist = new NamespaceList();
namespacelist.AddRange(interrogatePlugin);
namespacelist.Add(new NamespaceItem());
return(namespacelist);
}
//=====================================================================
/// <summary>
/// This is called to visit all namespaces, types, and members in the list of assemblies to be documented
/// </summary>
public void VisitApis()
{
// Store types. We have to do this after all assemblies are registered because the resolution may
// not work unless all the assemblies we need are in the resolver cache.
foreach(AssemblyNode assembly in assemblies)
{
this.StoreTypes(assembly.Types);
if(this.Canceled)
break;
}
if(!this.Canceled)
{
NamespaceList spaces = new NamespaceList();
foreach(Namespace space in catalog.Values)
if(filter.IsExposedNamespace(space))
spaces.Add(space);
if(!this.Canceled)
this.VisitNamespaces(spaces);
}
}
public virtual Differences VisitNamespaceList(NamespaceList list1, NamespaceList list2,
out NamespaceList changes, out NamespaceList deletions, out NamespaceList insertions){
changes = list1 == null ? null : list1.Clone();
deletions = list1 == null ? null : list1.Clone();
insertions = list1 == null ? new NamespaceList() : list1.Clone();
//^ assert insertions != null;
Differences differences = new Differences();
//Compare definitions that have matching key attributes
TrivialHashtable matchingPosFor = new TrivialHashtable();
TrivialHashtable matchedNodes = new TrivialHashtable();
for (int j = 0, n = list2 == null ? 0 : list2.Count; j < n; j++){
//^ assert list2 != null;
Namespace nd2 = list2[j];
if (nd2 == null || nd2.Name == null) continue;
matchingPosFor[nd2.Name.UniqueIdKey] = j;
insertions.Add(null);
}
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
Namespace nd1 = list1[i];
if (nd1 == null || nd1.Name == null) continue;
object pos = matchingPosFor[nd1.Name.UniqueIdKey];
if (!(pos is int)) continue;
//^ assert pos != null;
//^ assume list2 != null; //since there was entry int matchingPosFor
int j = (int)pos;
Namespace nd2 = list2[j];
//^ assume nd2 != null;
//nd1 and nd2 have the same key attributes and are therefore treated as the same entity
matchedNodes[nd1.UniqueKey] = nd1;
matchedNodes[nd2.UniqueKey] = nd2;
//nd1 and nd2 may still be different, though, so find out how different
Differences diff = this.VisitNamespace(nd1, nd2);
if (diff == null){Debug.Assert(false); continue;}
if (diff.NumberOfDifferences != 0){
changes[i] = diff.Changes as Namespace;
deletions[i] = diff.Deletions as Namespace;
insertions[i] = diff.Insertions as Namespace;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
Debug.Assert(diff.Changes == changes[i] && diff.Deletions == deletions[i] && diff.Insertions == insertions[i]);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
continue;
}
changes[i] = null;
deletions[i] = null;
insertions[i] = null;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
}
//Find deletions
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
Namespace nd1 = list1[i];
if (nd1 == null) continue;
if (matchedNodes[nd1.UniqueKey] != null) continue;
changes[i] = null;
deletions[i] = nd1;
insertions[i] = null;
differences.NumberOfDifferences += 1;
}
//Find insertions
for (int j = 0, n = list1 == null ? 0 : list1.Count, m = list2 == null ? 0 : list2.Count; j < m; j++){
//^ assert list2 != null;
Namespace nd2 = list2[j];
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
insertions[n+j] = nd2; //Records nd2 as an insertion into list1, along with its position in list2
differences.NumberOfDifferences += 1; //REVIEW: put the size of the tree here?
}
if (differences.NumberOfDifferences == 0){
changes = null;
deletions = null;
insertions = null;
}
return differences;
}
// Visit Object Model
public void VisitApis() {
// store types
// we have to do this after all assemblies are registered because the resolution may not work unless
// all the assemblies we need are in the resolver cache
//Console.WriteLine("storing types");
foreach (AssemblyNode assembly in assemblies) {
//Console.WriteLine("assembly {0}", assembly.Name);
//Console.WriteLine("has {0} types", assembly.Types.Count);
StoreTypes(assembly.Types);
//Console.WriteLine("done with assembly");
}
//Console.WriteLine("done storing types");
//Console.WriteLine("visiting namespaces");
NamespaceList spaces = new NamespaceList();
foreach (Namespace space in catalog.Values) {
if (filter.IsExposedNamespace(space)) spaces.Add(space);
}
VisitNamespaces(spaces);
}
