Author: toshok
Date: 2007-12-11 23:07:08 -0500 (Tue, 11 Dec 2007)
New Revision: 91138
Modified:
trunk/mono-tools/gui-compare/CecilMetadata.cs
trunk/mono-tools/gui-compare/CompareContext.cs
trunk/mono-tools/gui-compare/CompareWindow.cs
trunk/mono-tools/gui-compare/Comparison.cs
trunk/mono-tools/gui-compare/MasterMetadata.cs
trunk/mono-tools/gui-compare/Masterinfo.cs
trunk/mono-tools/gui-compare/Metadata.cs
Log:
lots of work refactoring and cleaning things up
Modified: trunk/mono-tools/gui-compare/CecilMetadata.cs
===================================================================
--- trunk/mono-tools/gui-compare/CecilMetadata.cs 2007-12-12 03:17:20 UTC
(rev 91137)
+++ trunk/mono-tools/gui-compare/CecilMetadata.cs 2007-12-12 04:07:08 UTC
(rev 91138)
@@ -3,14 +3,102 @@
using System.Text;
using System.Threading;
using System.Xml;
+using System.IO;
using Mono.Cecil;
using Gtk;
namespace GuiCompare {
+ static class Utils {
+ public static void PopulateMemberLists (TypeDefinition fromDef,
+ List<CompNamed>
interface_list,
+ List<CompNamed>
constructor_list,
+ List<CompNamed>
method_list,
+ List<CompNamed>
property_list,
+ List<CompNamed>
field_list,
+ List<CompNamed>
event_list)
+ {
+ if (interface_list != null) {
+ foreach (TypeReference ifc in
fromDef.Interfaces) {
+ interface_list.Add (new CecilInterface
(ifc, true));
+ }
+ }
+ if (constructor_list != null) {
+ foreach (MethodDefinition md in
fromDef.Constructors) {
+ if (md.IsPrivate || md.IsAssembly)
+ continue;
+ constructor_list.Add (new CecilMethod
(md));
+ }
+ }
+ if (method_list != null) {
+ foreach (MethodDefinition md in
fromDef.Methods) {
+ if (md.IsSpecialName)
+ continue;
+ if (md.IsPrivate || md.IsAssembly)
+ continue;
+ method_list.Add (new CecilMethod (md));
+ }
+ }
+ if (property_list != null) {
+#if notyet
+ foreach (PropertyDefinition pd in
fromDef.Properties) {
+ if (pd.IsPrivate || pd.IsAssembly)
+ property_list.Add (new
CecilProperty (pd));
+ }
+#endif
+ }
+ if (field_list != null) {
+ foreach (FieldDefinition fd in fromDef.Fields) {
+ if (fd.IsPrivate || fd.IsAssembly)
+ continue;
+ field_list.Add (new CecilField (fd));
+ }
+ }
+ if (event_list != null) {
+#if notyet
+ foreach (EventDefinition ed in fromDef.Events) {
+ if (ed.IsPrivate || ed.IsAssembly)
+ event_list.Add (new CecilEvent
(ed));
+ }
+#endif
+ }
+ }
+
+ public static void PopulateTypeLists (TypeDefinition fromDef,
+ List<CompNamed>
class_list,
+ List<CompNamed> enum_list,
+ List<CompNamed>
delegate_list,
+ List<CompNamed>
interface_list,
+ List<CompNamed>
struct_list)
+ {
+ foreach (TypeDefinition type_def in
fromDef.NestedTypes) {
+ if (type_def.IsNotPublic)
+ continue;
+ if (type_def.IsValueType) {
+ if (type_def.IsEnum) {
+ enum_list.Add (new CecilEnum
(type_def));
+ }
+ else {
+ struct_list.Add (new CecilClass
(type_def, CompType.Struct));
+ }
+ }
+ else if (type_def.IsInterface) {
+ interface_list.Add (new CecilInterface
(type_def, false));
+ }
+ else if (type_def.BaseType.FullName ==
"System.MulticastDelegate"
+ || type_def.BaseType.FullName ==
"System.Delegate") {
+ delegate_list.Add (new CecilDelegate
(type_def));
+ }
+ else {
+ class_list.Add (new CecilClass
(type_def, CompType.Class));
+ }
+ }
+ }
+ }
+
public class CecilAssembly : CompAssembly {
public CecilAssembly (string path)
- : base (path)
+ : base (Path.GetFileName (path))
{
Dictionary<string, Dictionary <string, TypeDefinition>>
namespaces
= new Dictionary<string, Dictionary <string,
TypeDefinition>> ();
@@ -37,15 +125,13 @@
namespaces[t.Namespace][t.Name] = t;
}
- namespace_list = new List<CompNamespace>();
+ namespace_list = new List<CompNamed>();
foreach (string ns_name in namespaces.Keys) {
namespace_list.Add (new CecilNamespace
(ns_name, namespaces[ns_name]));
}
-
- namespace_list.Sort (delegate (CompNamespace x,
CompNamespace y) { return String.Compare (x.Name, y.Name); });
}
- public override List<CompNamespace> GetNamespaces()
+ public override List<CompNamed> GetNamespaces()
{
return namespace_list;
}
@@ -61,127 +147,298 @@
}
- List<CompNamespace> namespace_list;
+ List<CompNamed> namespace_list;
}
public class CecilNamespace : CompNamespace {
- public CecilNamespace (string name, Dictionary<string,
TypeDefinition> class_mapping)
+ public CecilNamespace (string name, Dictionary<string,
TypeDefinition> type_mapping)
: base (name)
{
- class_list = new List<CompClass>();
-// enum_list = new List<CompEnum>();
-// delegate_list = new List<CompDelegate>();
- interface_list = new List<CompInterface>();
- struct_list = new List<CompClass>();
+ class_list = new List<CompNamed>();
+ enum_list = new List<CompNamed>();
+ delegate_list = new List<CompNamed>();
+ interface_list = new List<CompNamed>();
+ struct_list = new List<CompNamed>();
- foreach (string cls_name in class_mapping.Keys) {
- TypeDefinition type_def =
class_mapping[cls_name];
+ foreach (string type_name in type_mapping.Keys) {
+ TypeDefinition type_def =
type_mapping[type_name];
if (type_def.IsNotPublic)
continue;
if (type_def.IsValueType) {
if (type_def.IsEnum) {
- Console.WriteLine ("enum ->
{0}", type_def.FullName);
+ enum_list.Add (new CecilEnum
(type_def));
}
else {
- struct_list.Add (new CecilClass
(class_mapping[cls_name]));
+ struct_list.Add (new CecilClass
(type_def, CompType.Struct));
}
}
else if (type_def.IsInterface) {
- interface_list.Add (new CecilInterface
(class_mapping[cls_name]));
+ interface_list.Add (new CecilInterface
(type_def, false));
}
+ else if (type_def.BaseType.FullName ==
"System.MulticastDelegate"
+ || type_def.BaseType.FullName ==
"System.Delegate") {
+ delegate_list.Add (new CecilDelegate
(type_def));
+ }
else {
- class_list.Add (new CecilClass
(class_mapping[cls_name]));
+ class_list.Add (new CecilClass
(type_def, CompType.Class));
}
}
-
- class_list.Sort (delegate (CompClass x, CompClass y) {
return String.Compare (x.Name, y.Name); });
}
- public override List<CompClass> GetClasses()
+ public override List<CompNamed> GetNestedClasses()
{
return class_list;
}
- public override List<CompInterface> GetInterfaces ()
+ public override List<CompNamed> GetNestedInterfaces ()
{
return interface_list;
}
- public override List<CompClass> GetStructs ()
+ public override List<CompNamed> GetNestedStructs ()
{
return struct_list;
}
- List<CompClass> class_list;
- List<CompInterface> interface_list;
- List<CompClass> struct_list;
+ public override List<CompNamed> GetNestedEnums ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetNestedDelegates ()
+ {
+ return delegate_list;
+ }
+
+ List<CompNamed> class_list;
+ List<CompNamed> interface_list;
+ List<CompNamed> struct_list;
+ List<CompNamed> delegate_list;
+ List<CompNamed> enum_list;
}
public class CecilInterface : CompInterface {
- public CecilInterface (TypeReference type_ref)
- : base (type_ref.FullName)
+ public CecilInterface (TypeReference type_ref, bool full_name)
+ : base (full_name ? type_ref.FullName : type_ref.Name)
{
this.type_ref = type_ref;
}
+ public override List<CompNamed> GetInterfaces ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetMethods ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetConstructors ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetProperties()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetFields()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetEvents()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
TypeReference type_ref;
}
- public class CecilClass : CompClass {
- public CecilClass (TypeDefinition type_def)
+ public class CecilDelegate : CompDelegate {
+ public CecilDelegate (TypeDefinition type_def)
: base (type_def.Name)
{
this.type_def = type_def;
}
- public override List<CompInterface> GetInterfaces ()
+ TypeDefinition type_def;
+ }
+
+ public class CecilEnum : CompEnum {
+ public CecilEnum (TypeDefinition type_def)
+ : base (type_def.Name)
{
- List<CompInterface> rv = new List<CompInterface>();
+ this.type_def = type_def;
- foreach (TypeReference md in type_def.Interfaces) {
- rv.Add (new CecilInterface (md));
- }
+ fields = new List<CompNamed>();
- rv.Sort (delegate (CompInterface x, CompInterface y) {
return String.Compare (x.Name, y.Name); });
+ Utils.PopulateMemberLists (type_def,
+ null,
+ null,
+ null,
+ null,
+ fields,
+ null);
+ }
- return rv;
+ public override List<CompNamed> GetFields()
+ {
+ return fields;
}
- public override List<CompMethod> GetMethods ()
+ public override List<CompNamed> GetAttributes ()
{
- List<CompMethod> rv = new List<CompMethod>();
+ // XXX
+ return new List<CompNamed>();
+ }
- foreach (MethodDefinition md in type_def.Methods) {
- if (md.IsSpecialName)
- continue;
- rv.Add (new CecilMethod (md));
- }
+ TypeDefinition type_def;
+ List<CompNamed> fields;
+ }
- rv.Sort (delegate (CompMethod x, CompMethod y) { return
String.Compare (x.Name, y.Name); });
+ public class CecilClass : CompClass {
+ public CecilClass (TypeDefinition type_def, CompType type)
+ : base (type_def.Name, type)
+ {
+ this.type_def = type_def;
- return rv;
+ nested_classes = new List<CompNamed>();
+ nested_enums = new List<CompNamed>();
+ nested_delegates = new List<CompNamed>();
+ nested_interfaces = new List<CompNamed>();
+ nested_structs = new List<CompNamed>();
+
+ Utils.PopulateTypeLists (type_def,
+ nested_classes,
+ nested_enums,
+ nested_delegates,
+ nested_interfaces,
+ nested_structs);
+
+ interfaces = new List<CompNamed>();
+ constructors = new List<CompNamed>();
+ methods = new List<CompNamed>();
+ properties = new List<CompNamed>();
+ fields = new List<CompNamed>();
+ events = new List<CompNamed>();
+
+ Utils.PopulateMemberLists (type_def,
+ interfaces,
+ constructors,
+ methods,
+ properties,
+ fields,
+ events);
}
- public override List<CompMethod> GetConstructors ()
+ public override List<CompNamed> GetInterfaces ()
{
- return new List<CompMethod>();
+ return interfaces;
}
- public override List<CompClass> GetNestedClasses()
+ public override List<CompNamed> GetMethods ()
{
- List<CompClass> rv = new List<CompClass>();
- foreach (TypeDefinition td in type_def.NestedTypes) {
- rv.Add (new CecilClass (td));
- }
+ return methods;
+ }
- rv.Sort (delegate (CompClass x, CompClass y) { return
String.Compare (x.Name, y.Name); });
+ public override List<CompNamed> GetConstructors ()
+ {
+ return constructors;
+ }
- return rv;
+ public override List<CompNamed> GetProperties()
+ {
+ return properties;
}
+ public override List<CompNamed> GetFields()
+ {
+ return fields;
+ }
+
+ public override List<CompNamed> GetEvents()
+ {
+ return events;
+ }
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetNestedClasses()
+ {
+ return nested_classes;
+ }
+
+ public override List<CompNamed> GetNestedInterfaces ()
+ {
+ return nested_interfaces;
+ }
+
+ public override List<CompNamed> GetNestedStructs ()
+ {
+ return nested_structs;
+ }
+
+ public override List<CompNamed> GetNestedEnums ()
+ {
+ return nested_enums;
+ }
+
+ public override List<CompNamed> GetNestedDelegates ()
+ {
+ return nested_delegates;
+ }
+
TypeDefinition type_def;
+ List<CompNamed> nested_classes;
+ List<CompNamed> nested_interfaces;
+ List<CompNamed> nested_structs;
+ List<CompNamed> nested_delegates;
+ List<CompNamed> nested_enums;
+
+ List<CompNamed> interfaces;
+ List<CompNamed> constructors;
+ List<CompNamed> methods;
+ List<CompNamed> properties;
+ List<CompNamed> fields;
+ List<CompNamed> events;
}
+ public class CecilField : CompField {
+ public CecilField (FieldDefinition field_def)
+ : base (field_def.Name)
+ {
+ this.field_def = field_def;
+ }
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ FieldDefinition field_def;
+ }
+
public class CecilMethod : CompMethod {
public CecilMethod (MethodDefinition method_def)
: base (MasterinfoFormattedName (method_def))
@@ -189,6 +446,12 @@
this.method_def = method_def;
}
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
static string MasterinfoFormattedName (MethodDefinition
method_def)
{
StringBuilder sb = new StringBuilder ();
Modified: trunk/mono-tools/gui-compare/CompareContext.cs
===================================================================
--- trunk/mono-tools/gui-compare/CompareContext.cs 2007-12-12 03:17:20 UTC
(rev 91137)
+++ trunk/mono-tools/gui-compare/CompareContext.cs 2007-12-12 04:07:08 UTC
(rev 91138)
@@ -58,9 +58,9 @@
ProgressOnGuiThread (0.0, "Comparing...");
- comparison = new AssemblyComparison (Path.GetFileName
(assemblyPath));
+ comparison = assembly.GetComparisonNode ();
- CompareNamespaces (comparison);
+ CompareTypeLists (comparison,
masterinfo.GetNamespaces(), assembly.GetNamespaces());
FinishedOnGuiThread ();
@@ -90,319 +90,177 @@
}
}
- void CompareNamespaces (ComparisonNode parent)
+ void CompareNestedTypes (ComparisonNode parent,
ICompTypeContainer master_container, ICompTypeContainer assembly_container)
{
- List<CompNamespace> assembly_namespaces =
assembly.GetNamespaces();
- List<CompNamespace> master_namespaces =
masterinfo.GetNamespaces();
+ CompareTypeLists (parent,
+
master_container.GetNestedInterfaces(),
assembly_container.GetNestedInterfaces());
+ CompareTypeLists (parent,
+ master_container.GetNestedClasses(),
assembly_container.GetNestedClasses());
+ CompareTypeLists (parent,
+ master_container.GetNestedStructs(),
assembly_container.GetNestedStructs());
+ CompareTypeLists (parent,
+ master_container.GetNestedEnums(),
assembly_container.GetNestedEnums());
+ CompareTypeLists (parent,
+
master_container.GetNestedDelegates(), assembly_container.GetNestedDelegates());
+ }
+ void CompareTypeLists (ComparisonNode parent,
+ List<CompNamed> master_list,
+ List<CompNamed> assembly_list)
+ {
int m = 0, a = 0;
- while (m < master_namespaces.Count || a <
assembly_namespaces.Count) {
- if (m == master_namespaces.Count) {
- AddExtraNamespace (parent,
assembly_namespaces[a]);
+ master_list.Sort (CompNamed.Compare);
+ assembly_list.Sort (CompNamed.Compare);
+
+ while (m < master_list.Count || a <
assembly_list.Count) {
+ if (m == master_list.Count) {
+ AddExtra (parent, assembly_list[a]);
a++;
continue;
}
- else if (a == assembly_namespaces.Count) {
- AddMissingNamespace (parent,
master_namespaces[m]);
+ else if (a == assembly_list.Count) {
+ AddMissing (parent, master_list[m]);
m++;
continue;
}
- int c = String.Compare
(master_namespaces[m].Name, assembly_namespaces[a].Name);
+ int c = String.Compare (master_list[m].Name,
assembly_list[a].Name);
if (c == 0) {
- ProgressOnGuiThread (0.0, String.Format
("Comparing namespace {0}", master_namespaces[m].Name));
+ ProgressOnGuiThread (0.0, String.Format
("Comparing {0} {0}", master_list[m].Type, master_list[m].Name));
/* the names match, further
investigation is required */
-// Console.WriteLine ("namespace {0} is in
both, doing more comparisons", master_namespaces[m].Name);
- NamespaceComparison comparison = new
NamespaceComparison (master_namespaces[m].Name);
+// Console.WriteLine ("{0} {1} is in both,
doing more comparisons", master_list[m].Type, master_list[m].Name);
+ ComparisonNode comparison =
master_list[m].GetComparisonNode();
parent.AddChild (comparison);
- CompareTypes (comparison,
master_namespaces[m], assembly_namespaces[a]);
- m++;
- a++;
- }
- else if (c < 0) {
- /* master name is before assembly name,
master name is missing from assembly */
- AddMissingNamespace (parent,
master_namespaces[m]);
- m++;
- }
- else {
- /* master name is after assembly name,
assembly name is extra */
- AddExtraNamespace (parent,
assembly_namespaces[a]);
- a++;
- }
- }
- }
- void CompareClassLists (ComparisonNode parent,
- List<CompClass> master_types,
List<CompClass> assembly_types)
- {
- int m = 0, a = 0;
- while (m < master_types.Count || a <
assembly_types.Count) {
- if (master_types == null || m ==
master_types.Count) {
- AddExtraClass (parent,
assembly_types[a]);
- a++;
- continue;
- }
- else if (assembly_types == null || a ==
assembly_types.Count) {
- AddMissingClass (parent,
master_types[m]);
- m++;
- continue;
- }
+ // compare nested types
+ if (master_list[m] is
ICompTypeContainer && assembly_list[a] is ICompTypeContainer) {
+ CompareNestedTypes (comparison,
+
(ICompTypeContainer)master_list[m],
+
(ICompTypeContainer)assembly_list[a]);
+ }
+ if (master_list[m] is
ICompMemberContainer && assembly_list[a] is ICompMemberContainer) {
+ CompareMembers (comparison,
+
(ICompMemberContainer)master_list[m],
+
(ICompMemberContainer)assembly_list[a]);
+ }
- int c = String.Compare (master_types[m].Name,
assembly_types[a].Name);
-
- if (c == 0) {
- /* the names match, further
investigation is required */
- ClassComparison comparison = new
ClassComparison (master_types[m].Name);
- parent.AddChild (comparison);
- CompareInterfaces (comparison,
master_types[m], assembly_types[a]);
- CompareMethods (comparison,
master_types[m], assembly_types[a]);
- // XXX more comparison stuff here
- CompareClassLists (comparison,
-
master_types[m].GetNestedClasses(),
-
assembly_types[a].GetNestedClasses());
+ // XXX compare members
m++;
a++;
}
else if (c < 0) {
/* master name is before assembly name,
master name is missing from assembly */
- AddMissingClass (parent,
master_types[m]);
+ AddMissing (parent, master_list[m]);
m++;
}
else {
/* master name is after assembly name,
assembly name is extra */
- AddExtraClass (parent,
assembly_types[a]);
+ AddExtra (parent, assembly_list[a]);
a++;
}
}
}
- void CompareTypes (NamespaceComparison parent,
- CompNamespace master_namespace,
CompNamespace assembly_namespace)
+ void CompareMembers (ComparisonNode parent,
+ ICompMemberContainer master_container,
ICompMemberContainer assembly_container)
{
- CompareClassLists (parent,
- master_namespace.GetClasses(),
assembly_namespace.GetClasses());
- CompareStructs (parent,
- master_namespace, assembly_namespace);
+ CompareMemberLists (parent,
+ master_container.GetInterfaces(),
assembly_container.GetInterfaces());
+ CompareMemberLists (parent,
+ master_container.GetMethods(),
assembly_container.GetMethods());
+ CompareMemberLists (parent,
+ master_container.GetProperties(),
assembly_container.GetProperties());
+ CompareMemberLists (parent,
+ master_container.GetFields(),
assembly_container.GetFields());
}
- void CompareStructs (ComparisonNode parent,
- CompNamespace master_namespace,
CompNamespace assembly_namespace)
+ void CompareMemberLists (ComparisonNode parent,
+ List<CompNamed> master_list,
+ List<CompNamed> assembly_list)
{
- List<CompClass> assembly_structs =
assembly_namespace.GetStructs();
- List<CompClass> master_structs =
master_namespace.GetStructs();
-
int m = 0, a = 0;
- while (m < master_structs.Count || a <
assembly_structs.Count) {
- if (m == master_structs.Count) {
- Console.WriteLine ("{0}",
assembly_namespace.Name);
- AddExtraStruct (parent,
assembly_structs[a]);
- a++;
- continue;
- }
- else if (a == assembly_structs.Count) {
- Console.WriteLine ("{0}",
master_namespace.Name);
- AddMissingStruct (parent,
master_structs[m]);
- m++;
- continue;
- }
- int c = String.Compare (master_structs[m].Name,
assembly_structs[a].Name);
+ master_list.Sort (CompNamed.Compare);
+ assembly_list.Sort (CompNamed.Compare);
- if (c == 0) {
- /* the names match, further
investigation is required */
- Console.WriteLine ("struct {0} is in
both, doing more comparisons", master_structs[m].Name);
- StructComparison comparison = new
StructComparison (master_structs[m].Name);
- parent.AddChild (comparison);
- m++;
+ while (m < master_list.Count || a <
assembly_list.Count) {
+ if (m == master_list.Count) {
+ AddExtra (parent, assembly_list[a]);
a++;
- }
- else if (c < 0) {
- Console.WriteLine ("{0}",
master_namespace.Name);
- /* master name is before assembly name,
master name is missing from assembly */
- AddMissingStruct (parent,
master_structs[m]);
- m++;
- }
- else {
- Console.WriteLine ("{0}",
assembly_namespace.Name);
- /* master name is after assembly name,
assembly name is extra */
- AddExtraStruct (parent,
assembly_structs[a]);
- a++;
- }
- }
- }
-
- void CompareInterfaces (ComparisonNode parent,
- CompClass master_class, CompClass
assembly_class)
- {
- List<CompInterface> assembly_interfaces =
assembly_class.GetInterfaces();
- List<CompInterface> master_interfaces =
master_class.GetInterfaces();
-
- int m = 0, a = 0;
- while (m < master_interfaces.Count || a <
assembly_interfaces.Count) {
- if (m == master_interfaces.Count) {
- Console.WriteLine ("{0}",
assembly_class.Name);
- AddExtraInterface (parent,
assembly_interfaces[a]);
- a++;
continue;
}
- else if (a == assembly_interfaces.Count) {
- Console.WriteLine ("{0}",
master_class.Name);
- AddMissingInterface (parent,
master_interfaces[m]);
+ else if (a == assembly_list.Count) {
+ AddMissing (parent, master_list[m]);
m++;
continue;
}
- int c = String.Compare
(master_interfaces[m].Name, assembly_interfaces[a].Name);
+ int c = String.Compare (master_list[m].Name,
assembly_list[a].Name);
if (c == 0) {
/* the names match, further
investigation is required */
- Console.WriteLine ("interface {0} is in
both, doing more comparisons", master_interfaces[m].Name);
- InterfaceComparison comparison = new
InterfaceComparison (master_interfaces[m].Name);
+// Console.WriteLine ("method {0} is in
both, doing more comparisons", master_list[m].Name);
+ ComparisonNode comparison =
master_list[m].GetComparisonNode();
parent.AddChild (comparison);
+ //CompareParameters (comparison,
master_list[m], assembly_namespace [assembly_list[a]]);
m++;
a++;
}
else if (c < 0) {
- Console.WriteLine ("{0}",
master_class.Name);
/* master name is before assembly name,
master name is missing from assembly */
- AddMissingInterface (parent,
master_interfaces[m]);
+ AddMissing (parent, master_list[m]);
m++;
}
else {
- Console.WriteLine ("{0}",
assembly_class.Name);
/* master name is after assembly name,
assembly name is extra */
- AddExtraInterface (parent,
assembly_interfaces[a]);
+ AddExtra (parent, assembly_list[a]);
a++;
}
}
}
- void CompareMethods (ComparisonNode parent,
- CompClass master_class, CompClass
assembly_class)
+ void AddExtra (ComparisonNode parent, CompNamed item)
{
- List<CompMethod> assembly_methods =
assembly_class.GetMethods();
- List<CompMethod> master_methods =
master_class.GetMethods();
+ ComparisonNode node = item.GetComparisonNode ();
+ parent.AddChild (node);
+ node.status = ComparisonStatus.Extra;
- int m = 0, a = 0;
- while (m < master_methods.Count || a <
assembly_methods.Count) {
- if (m == master_methods.Count) {
- AddExtraMethod (parent,
assembly_methods[a]);
- a++;
- continue;
- }
- else if (a == assembly_methods.Count) {
- AddMissingMethod (parent,
master_methods[m]);
- m++;
- continue;
- }
-
- int c = String.Compare (master_methods[m].Name,
assembly_methods[a].Name);
-
- if (c == 0) {
- /* the names match, further
investigation is required */
-// Console.WriteLine ("method {0} is in
both, doing more comparisons", master_methods[m].Name);
- MethodComparison comparison = new
MethodComparison (master_methods[m].Name);
- parent.AddChild (comparison);
- //CompareParameters (comparison,
master_methods[m], assembly_namespace [assembly_methods[a]]);
- m++;
- a++;
- }
- else if (c < 0) {
- /* master name is before assembly name,
master name is missing from assembly */
- AddMissingMethod (parent,
master_methods[m]);
- m++;
- }
- else {
- /* master name is after assembly name,
assembly name is extra */
- AddExtraMethod (parent,
assembly_methods[a]);
- a++;
- }
+ if (item is ICompTypeContainer) {
+ ICompTypeContainer c = (ICompTypeContainer)item;
+ foreach (CompNamed ifc in c.GetNestedInterfaces
())
+ AddExtra (node, ifc);
+ foreach (CompNamed cls in c.GetNestedClasses())
+ AddExtra (node, cls);
+ foreach (CompNamed cls in c.GetNestedStructs())
+ AddExtra (node, cls);
+ foreach (CompNamed en in c.GetNestedEnums())
+ AddExtra (node, en);
}
}
- void AddExtraNamespace (ComparisonNode parent, CompNamespace ns)
+ void AddMissing (ComparisonNode parent, CompNamed item)
{
- ComparisonNode namespace_node = new NamespaceComparison
(ns.Name);
- parent.AddChild (namespace_node);
- namespace_node.status = ComparisonStatus.Extra;
+ ComparisonNode node = item.GetComparisonNode ();
+ parent.AddChild (node);
+ node.status = ComparisonStatus.Missing;
- List<CompClass> classes = ns.GetClasses();
- foreach (CompClass cls in classes)
- AddExtraClass (namespace_node, cls);
- }
+ if (item is ICompTypeContainer) {
+ ICompTypeContainer c = (ICompTypeContainer)item;
- void AddMissingNamespace (ComparisonNode parent, CompNamespace
ns)
- {
- ComparisonNode namespace_node = new NamespaceComparison
(ns.Name);
- parent.AddChild (namespace_node);
- namespace_node.status = ComparisonStatus.Missing;
-
- List<CompClass> classes = ns.GetClasses();
- foreach (CompClass cls in classes)
- AddMissingClass (namespace_node, cls);
+ foreach (CompNamed ifc in c.GetNestedInterfaces
())
+ AddMissing (node, ifc);
+ foreach (CompNamed cls in c.GetNestedClasses())
+ AddMissing (node, cls);
+ foreach (CompNamed cls in c.GetNestedStructs())
+ AddMissing (node, cls);
+ foreach (CompNamed en in c.GetNestedEnums())
+ AddMissing (node, en);
+ }
}
- void AddExtraClass (ComparisonNode parent, CompClass cls)
- {
- ClassComparison comparison = new ClassComparison
(cls.Name);
- parent.AddChild (comparison);
- comparison.status = ComparisonStatus.Extra;
- }
-
- void AddMissingClass (ComparisonNode parent, CompClass cls)
- {
- ClassComparison comparison = new ClassComparison
(cls.Name);
- parent.AddChild (comparison);
- comparison.status = ComparisonStatus.Missing;
- }
-
- void AddExtraStruct (ComparisonNode parent, CompClass cls)
- {
- StructComparison comparison = new StructComparison
(cls.Name);
- parent.AddChild (comparison);
- comparison.status = ComparisonStatus.Extra;
- }
-
- void AddMissingStruct (ComparisonNode parent, CompClass cls)
- {
- StructComparison comparison = new StructComparison
(cls.Name);
- parent.AddChild (comparison);
- comparison.status = ComparisonStatus.Missing;
- }
-
- void AddExtraInterface (ComparisonNode parent, CompInterface
cls)
- {
- Console.WriteLine ("extra interface {0}", cls.Name);
- InterfaceComparison comparison = new
InterfaceComparison (cls.Name);
- parent.AddChild (comparison);
- comparison.status = ComparisonStatus.Extra;
- }
-
- void AddMissingInterface (ComparisonNode parent, CompInterface
cls)
- {
- Console.WriteLine ("missing interface {0}", cls.Name);
- InterfaceComparison comparison = new
InterfaceComparison (cls.Name);
- parent.AddChild (comparison);
- comparison.status = ComparisonStatus.Missing;
- }
-
- void AddExtraMethod (ComparisonNode parent, CompMethod extra)
- {
- ComparisonNode method_node = new MethodComparison
(extra.Name);
- parent.AddChild (method_node);
- method_node.status = ComparisonStatus.Extra;
- }
-
- void AddMissingMethod (ComparisonNode parent, CompMethod
missing)
- {
- ComparisonNode method_node = new MethodComparison
(missing.Name);
- parent.AddChild (method_node);
- method_node.status = ComparisonStatus.Missing;
- }
-
void LoadMasterinfo ()
{
masterinfo = new MasterAssembly (masterinfoPath);
@@ -446,7 +304,7 @@
string masterinfoPath;
string assemblyPath;
- AssemblyComparison comparison;
+ ComparisonNode comparison;
Thread t;
}
Modified: trunk/mono-tools/gui-compare/CompareWindow.cs
===================================================================
--- trunk/mono-tools/gui-compare/CompareWindow.cs 2007-12-12 03:17:20 UTC
(rev 91137)
+++ trunk/mono-tools/gui-compare/CompareWindow.cs 2007-12-12 04:07:08 UTC
(rev 91138)
@@ -63,6 +63,7 @@
// Create a column for the node name
Gtk.TreeViewColumn nameColumn = new Gtk.TreeViewColumn
();
nameColumn.Title = "Name";
+ nameColumn.Resizable = true;
Gtk.CellRendererText nameCell = new
Gtk.CellRendererText ();
Gtk.CellRendererPixbuf typeCell = new
Gtk.CellRendererPixbuf ();
@@ -81,6 +82,7 @@
// Create a column for the status counts
Gtk.TreeViewColumn countsColumn = new
Gtk.TreeViewColumn ();
countsColumn.Title = "Counts";
+ countsColumn.Resizable = true;
Gtk.CellRendererPixbuf missingPixbufCell = new
Gtk.CellRendererPixbuf ();
Gtk.CellRendererText missingTextCell = new
Gtk.CellRendererText ();
@@ -174,16 +176,18 @@
Gdk.Pixbuf TypePixbufFromComparisonNode (ComparisonNode node)
{
switch (node.type) {
- case ComparisonNodeType.Assembly: return assemblyPixbuf;
- case ComparisonNodeType.Namespace: return
namespacePixbuf;
- case ComparisonNodeType.Attribute: return
attributePixbuf;
- case ComparisonNodeType.Interface: return
interfacePixbuf;
- case ComparisonNodeType.Class: return classPixbuf;
- case ComparisonNodeType.Struct: return structPixbuf;
- case ComparisonNodeType.Enum: return enumPixbuf;
- case ComparisonNodeType.Method: return methodPixbuf;
- case ComparisonNodeType.Property: return propertyPixbuf;
- case ComparisonNodeType.Field: return fieldPixbuf;
+ case CompType.Assembly: return assemblyPixbuf;
+ case CompType.Namespace: return namespacePixbuf;
+ case CompType.Attribute: return attributePixbuf;
+ case CompType.Interface: return interfacePixbuf;
+ case CompType.Class: return classPixbuf;
+ case CompType.Struct: return structPixbuf;
+ case CompType.Delegate: return delegatePixbuf;
+ case CompType.Enum: return enumPixbuf;
+ case CompType.Method: return methodPixbuf;
+ case CompType.Property: return propertyPixbuf;
+ case CompType.Field: return fieldPixbuf;
+ case CompType.Event: return eventPixbuf;
}
return null;
}
Modified: trunk/mono-tools/gui-compare/Comparison.cs
===================================================================
--- trunk/mono-tools/gui-compare/Comparison.cs 2007-12-12 03:17:20 UTC (rev
91137)
+++ trunk/mono-tools/gui-compare/Comparison.cs 2007-12-12 04:07:08 UTC (rev
91138)
@@ -8,19 +8,6 @@
namespace GuiCompare {
- public enum ComparisonNodeType {
- Assembly,
- Namespace,
- Attribute,
- Interface,
- Class,
- Struct,
- Enum,
- Method,
- Property,
- Field
- }
-
public enum ComparisonStatus {
None,
Missing,
@@ -30,7 +17,7 @@
}
public class ComparisonNode {
- public ComparisonNode (ComparisonNodeType type,
+ public ComparisonNode (CompType type,
string name)
{
this.type = type;
@@ -58,7 +45,7 @@
public ComparisonStatus status;
- public ComparisonNodeType type;
+ public CompType type;
public ComparisonNode parent;
@@ -72,68 +59,4 @@
public List<ComparisonNode> children;
}
-
- /* represents the result of comparing a masterinfo to a local assembly
*/
- public class AssemblyComparison : ComparisonNode {
- public AssemblyComparison (string name)
- : base (ComparisonNodeType.Assembly, name)
- {
- }
- }
-
- public class NamespaceComparison : ComparisonNode {
- public NamespaceComparison (string name)
- : base (ComparisonNodeType.Namespace, name)
- {
- }
- }
-
- public class ClassComparison : ComparisonNode {
- public ClassComparison (string name)
- : base (ComparisonNodeType.Class, name)
- {
- }
- }
-
- public class InterfaceComparison : ComparisonNode {
- public InterfaceComparison (string name)
- : base (ComparisonNodeType.Interface, name)
- {
- }
- }
-
- public class StructComparison : ComparisonNode {
- public StructComparison (string name)
- : base (ComparisonNodeType.Struct, name)
- {
- }
- }
-
- public class FieldComparison : ComparisonNode {
- public FieldComparison (string name)
- : base (ComparisonNodeType.Field, name)
- {
- }
- }
-
- public class MethodComparison : ComparisonNode {
- public MethodComparison (string name)
- : base (ComparisonNodeType.Method, name)
- {
- }
- }
-
- public class PropertyComparison : ComparisonNode {
- public PropertyComparison (string name)
- : base (ComparisonNodeType.Property, name)
- {
- }
- }
-
- public class AttributeComparison : ComparisonNode {
- public AttributeComparison (string name)
- : base (ComparisonNodeType.Attribute, name)
- {
- }
- }
}
Modified: trunk/mono-tools/gui-compare/MasterMetadata.cs
===================================================================
--- trunk/mono-tools/gui-compare/MasterMetadata.cs 2007-12-12 03:17:20 UTC
(rev 91137)
+++ trunk/mono-tools/gui-compare/MasterMetadata.cs 2007-12-12 04:07:08 UTC
(rev 91138)
@@ -14,14 +14,12 @@
masterinfo = XMLAssembly.CreateFromFile (path);
}
- public override List<CompNamespace> GetNamespaces ()
+ public override List<CompNamed> GetNamespaces ()
{
- List<CompNamespace> namespaces = new
List<CompNamespace>();
+ List<CompNamed> namespaces = new List<CompNamed>();
foreach (XMLNamespace ns in masterinfo.namespaces)
namespaces.Add (new MasterNamespace (ns));
- namespaces.Sort(delegate (CompNamespace x,
CompNamespace y) { return String.Compare (x.Name, y.Name); });
-
return namespaces;
}
@@ -33,30 +31,59 @@
: base (ns.name)
{
this.ns = ns;
+
+ delegate_list = new List<CompNamed>();
+ enum_list = new List<CompNamed>();
+ class_list = new List<CompNamed>();
+ struct_list = new List<CompNamed>();
+ interface_list = new List<CompNamed>();
+
+ foreach (XMLClass cls in ns.types) {
+ if (cls.type == "class")
+ class_list.Add (new MasterClass (cls,
CompType.Class));
+ else if (cls.type == "enum")
+ enum_list.Add (new MasterEnum (cls));
+ else if (cls.type == "delegate")
+ delegate_list.Add (new MasterDelegate
(cls));
+ else if (cls.type == "interface")
+ interface_list.Add (new MasterInterface
(cls.name));
+ else if (cls.type == "struct")
+ struct_list.Add (new MasterClass (cls,
CompType.Struct));
+ }
}
- public override List<CompClass> GetClasses ()
+ public override List<CompNamed> GetNestedClasses ()
{
- List<CompClass> classes = new List<CompClass>();
- foreach (XMLClass cls in ns.types)
- classes.Add (new MasterClass (cls));
+ return class_list;
+ }
- classes.Sort(delegate (CompClass x, CompClass y) {
return String.Compare (x.Name, y.Name); });
+ public override List<CompNamed> GetNestedInterfaces ()
+ {
+ return interface_list;
+ }
- return classes;
+ public override List<CompNamed> GetNestedStructs ()
+ {
+ return struct_list;
}
- public override List<CompInterface> GetInterfaces ()
+ public override List<CompNamed> GetNestedEnums ()
{
- return new List<CompInterface>();
+ return enum_list;
}
- public override List<CompClass> GetStructs ()
+ public override List<CompNamed> GetNestedDelegates ()
{
- return new List<CompClass>();
+ return delegate_list;
}
+
XMLNamespace ns;
+ List<CompNamed> delegate_list;
+ List<CompNamed> enum_list;
+ List<CompNamed> class_list;
+ List<CompNamed> struct_list;
+ List<CompNamed> interface_list;
}
public class MasterInterface : CompInterface {
@@ -64,19 +91,94 @@
: base (name)
{
}
+
+ public override List<CompNamed> GetInterfaces ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetMethods ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetConstructors ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetProperties()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetFields()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetEvents()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
}
- public class MasterClass : CompClass {
- public MasterClass (XMLClass cls)
+ public class MasterDelegate : CompDelegate {
+ public MasterDelegate (XMLClass cls)
: base (cls.name)
{
xml_cls = cls;
}
- public override List<CompInterface> GetInterfaces ()
+ XMLClass xml_cls;
+ }
+
+ public class MasterEnum : CompEnum {
+ public MasterEnum (XMLClass cls)
+ : base (cls.name)
{
- List<CompInterface> rv = new List<CompInterface>();
+ xml_cls = cls;
+ }
+ public override List<CompNamed> GetFields()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+
+ XMLClass xml_cls;
+ }
+
+ public class MasterClass : CompClass {
+ public MasterClass (XMLClass cls, CompType type)
+ : base (cls.name, type)
+ {
+ xml_cls = cls;
+ }
+
+ public override List<CompNamed> GetInterfaces ()
+ {
+ List<CompNamed> rv = new List<CompNamed>();
+
if (xml_cls.interfaces != null) {
foreach (object i in
xml_cls.interfaces.keys.Keys) {
rv.Add (new MasterInterface
((string)xml_cls.interfaces.keys[i]));
@@ -87,38 +189,80 @@
return rv;
}
- public override List<CompMethod> GetMethods()
+ public override List<CompNamed> GetMethods()
{
- List<CompMethod> rv = new List<CompMethod>();
+ List<CompNamed> rv = new List<CompNamed>();
if (xml_cls.methods != null) {
foreach (object key in
xml_cls.methods.keys.Keys) {
rv.Add (new MasterMethod
((string)xml_cls.methods.keys[key]));
}
}
- rv.Sort (delegate (CompMethod x, CompMethod y) { return
String.Compare (x.Name, y.Name); });
-
return rv;
}
- public override List<CompMethod> GetConstructors()
+ public override List<CompNamed> GetConstructors()
{
- return new List<CompMethod>();
+ return new List<CompNamed>();
}
- public override List<CompClass> GetNestedClasses()
+ public override List<CompNamed> GetProperties()
{
- List<CompClass> rv = new List<CompClass>();
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetFields()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetEvents()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetNestedClasses()
+ {
+ List<CompNamed> rv = new List<CompNamed>();
if (xml_cls.nested != null) {
foreach (XMLClass nested in xml_cls.nested)
- rv.Add (new MasterClass (nested));
-
- rv.Sort (delegate (CompClass x, CompClass y) {
return String.Compare (x.Name, y.Name); });
+ rv.Add (new MasterClass (nested,
CompType.Class));
}
return rv;
}
+ public override List<CompNamed> GetNestedInterfaces ()
+ {
+ return new List<CompNamed>();;
+ }
+
+ public override List<CompNamed> GetNestedStructs ()
+ {
+ return new List<CompNamed>();;
+ }
+
+ public override List<CompNamed> GetNestedEnums ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
+ public override List<CompNamed> GetNestedDelegates ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
XMLClass xml_cls;
}
@@ -128,5 +272,12 @@
: base (name)
{
}
+
+ public override List<CompNamed> GetAttributes ()
+ {
+ // XXX
+ return new List<CompNamed>();
+ }
+
}
}
Modified: trunk/mono-tools/gui-compare/Masterinfo.cs
===================================================================
--- trunk/mono-tools/gui-compare/Masterinfo.cs 2007-12-12 03:17:20 UTC (rev
91137)
+++ trunk/mono-tools/gui-compare/Masterinfo.cs 2007-12-12 04:07:08 UTC (rev
91138)
@@ -628,7 +628,7 @@
public class XMLClass : XMLData
{
public string name;
- string type;
+ public string type;
string baseName;
bool isSealed;
bool isSerializable;
Modified: trunk/mono-tools/gui-compare/Metadata.cs
===================================================================
--- trunk/mono-tools/gui-compare/Metadata.cs 2007-12-12 03:17:20 UTC (rev
91137)
+++ trunk/mono-tools/gui-compare/Metadata.cs 2007-12-12 04:07:08 UTC (rev
91138)
@@ -9,14 +9,50 @@
namespace GuiCompare {
+ public enum CompType {
+ Assembly,
+ Namespace,
+ Attribute,
+ Interface,
+ Class,
+ Struct,
+ Enum,
+ Method,
+ Property,
+ Field,
+ Delegate,
+ Event
+ }
+
+ public interface ICompAttributeContainer
+ {
+ List<CompNamed> GetAttributes ();
+ }
+
+ public interface ICompTypeContainer
+ {
+ List<CompNamed> GetNestedClasses();
+ List<CompNamed> GetNestedInterfaces ();
+ List<CompNamed> GetNestedStructs ();
+ List<CompNamed> GetNestedEnums ();
+ List<CompNamed> GetNestedDelegates ();
+ }
+
+ public interface ICompMemberContainer
+ {
+ List<CompNamed> GetInterfaces ();
+ List<CompNamed> GetConstructors();
+ List<CompNamed> GetMethods();
+ List<CompNamed> GetProperties();
+ List<CompNamed> GetFields();
+ List<CompNamed> GetEvents();
+ }
+
public abstract class CompNamed {
- public CompNamed ()
+ public CompNamed (string name, CompType type)
{
- }
-
- public CompNamed (string name)
- {
this.name = name;
+ this.type = type;
}
public string Name {
@@ -24,61 +60,145 @@
get { return name; }
}
+ public CompType Type {
+ set { type = value; }
+ get { return type; }
+ }
+
+ public ComparisonNode GetComparisonNode ()
+ {
+ return new ComparisonNode (type, name);
+ }
+
+ public static int Compare (CompNamed x, CompNamed y)
+ {
+ return String.Compare (x.Name, y.Name);
+ }
+
string name;
+ CompType type;
}
public abstract class CompAssembly : CompNamed {
public CompAssembly (string name)
- : base (name)
+ : base (name, CompType.Assembly)
{
}
- public abstract List<CompNamespace> GetNamespaces();
+ public abstract List<CompNamed> GetNamespaces();
}
- public abstract class CompNamespace : CompNamed {
+ public abstract class CompNamespace : CompNamed, ICompTypeContainer {
public CompNamespace (string name)
- : base (name)
+ : base (name, CompType.Namespace)
{
}
- public abstract List<CompClass> GetClasses();
- public abstract List<CompInterface> GetInterfaces ();
- public abstract List<CompClass> GetStructs ();
+ // ICompTypeContainer implementation
+ public abstract List<CompNamed> GetNestedClasses();
+ public abstract List<CompNamed> GetNestedInterfaces ();
+ public abstract List<CompNamed> GetNestedStructs ();
+ public abstract List<CompNamed> GetNestedEnums ();
+ public abstract List<CompNamed> GetNestedDelegates ();
}
- public interface ICompAttributeContainer
- {
-// public List<CompAttribute> GetAttributes ();
+ public abstract class CompInterface : CompNamed,
ICompAttributeContainer, ICompMemberContainer {
+ public CompInterface (string name)
+ : base (name, CompType.Interface)
+ {
+ }
+
+ public abstract List<CompNamed> GetAttributes ();
+
+ public abstract List<CompNamed> GetInterfaces ();
+ public abstract List<CompNamed> GetConstructors();
+ public abstract List<CompNamed> GetMethods();
+ public abstract List<CompNamed> GetProperties();
+ public abstract List<CompNamed> GetFields();
+ public abstract List<CompNamed> GetEvents();
}
- public abstract class CompInterface : CompNamed,
ICompAttributeContainer {
- public CompInterface (string name)
- : base (name)
+ public abstract class CompEnum : CompNamed, ICompAttributeContainer,
ICompMemberContainer {
+ public CompEnum (string name)
+ : base (name, CompType.Enum)
{
}
+
+ public List<CompNamed> GetInterfaces () { return new
List<CompNamed>(); }
+ public List<CompNamed> GetConstructors() { return new
List<CompNamed>(); }
+ public List<CompNamed> GetMethods() { return new
List<CompNamed>(); }
+ public List<CompNamed> GetProperties() { return new
List<CompNamed>(); }
+ public List<CompNamed> GetEvents() { return new
List<CompNamed>(); }
+
+ public abstract List<CompNamed> GetFields();
+
+ public abstract List<CompNamed> GetAttributes ();
}
- public abstract class CompClass : CompNamed, ICompAttributeContainer {
- public CompClass (string name)
- : base (name)
+ public abstract class CompDelegate : CompNamed {
+ public CompDelegate (string name)
+ : base (name, CompType.Delegate)
{
}
- public abstract List<CompInterface> GetInterfaces ();
- public abstract List<CompMethod> GetConstructors();
- public abstract List<CompMethod> GetMethods();
-// public abstract List<CompProperty> GetProperties();
-// public abstract List<CompField> GetFields();
-// public abstract List<CompEvent> GetEvents();
+ }
- public abstract List<CompClass> GetNestedClasses();
+ public abstract class CompClass : CompNamed, ICompAttributeContainer,
ICompTypeContainer, ICompMemberContainer {
+ public CompClass (string name, CompType type)
+ : base (name, type)
+ {
+ }
+
+ public abstract List<CompNamed> GetInterfaces();
+ public abstract List<CompNamed> GetConstructors();
+ public abstract List<CompNamed> GetMethods();
+ public abstract List<CompNamed> GetProperties();
+ public abstract List<CompNamed> GetFields();
+ public abstract List<CompNamed> GetEvents();
+
+ public abstract List<CompNamed> GetAttributes ();
+
+ public abstract List<CompNamed> GetNestedClasses();
+ public abstract List<CompNamed> GetNestedInterfaces ();
+ public abstract List<CompNamed> GetNestedStructs ();
+ public abstract List<CompNamed> GetNestedEnums ();
+ public abstract List<CompNamed> GetNestedDelegates ();
}
- public abstract class CompMethod : CompNamed, ICompAttributeContainer {
+ public abstract class CompMember : CompNamed, ICompAttributeContainer {
+ public CompMember (string name, CompType type)
+ : base (name, type)
+ {
+ }
+
+ public abstract List<CompNamed> GetAttributes ();
+ }
+
+ public abstract class CompMethod : CompMember {
public CompMethod (string name)
- : base (name)
+ : base (name, CompType.Method)
{
}
}
+
+ public abstract class CompProperty : CompMember {
+ public CompProperty (string name)
+ : base (name, CompType.Property)
+ {
+ }
+ }
+
+ public abstract class CompField : CompMember {
+ public CompField (string name)
+ : base (name, CompType.Field)
+ {
+ }
+ }
+
+ public abstract class CompEvent : CompMember {
+ public CompEvent (string name)
+ : base (name, CompType.Event)
+ {
+ }
+ }
}
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
