public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
{
this.document = doc;
XMLClass oclass = (XMLClass) other;
if (attributes != null || oclass.attributes != null) {
if (attributes == null)
attributes = new XMLAttributes ();
attributes.CompareTo (doc, parent, oclass.attributes);
counters.AddPartialToPartial (attributes.Counters);
if (oclass.attributes != null && oclass.attributes.IsTodo) {
counters.Todo++;
counters.TodoTotal++;
counters.ErrorTotal++;
AddAttribute (parent, "error", "todo");
if (oclass.attributes.Comment != null)
AddAttribute (parent, "comment", oclass.attributes.Comment);
}
}
if (type != oclass.type)
AddWarning (parent, "Class type is wrong: {0} != {1}", type, oclass.type);
if (baseName != oclass.baseName)
AddWarning (parent, "Base class is wrong: {0} != {1}", baseName, oclass.baseName);
if (isAbstract != oclass.isAbstract || isSealed != oclass.isSealed) {
if ((isAbstract && isSealed) || (oclass.isAbstract && oclass.isSealed))
AddWarning (parent, "Should {0}be static", (isAbstract && isSealed) ? "" : "not ");
else if (isAbstract != oclass.isAbstract)
AddWarning (parent, "Should {0}be abstract", isAbstract ? "" : "not ");
else if (isSealed != oclass.isSealed)
AddWarning (parent, "Should {0}be sealed", isSealed ? "" : "not ");
}
if (isSerializable != oclass.isSerializable)
AddWarning (parent, "Should {0}be serializable", isSerializable ? "" : "not ");
if (charSet != oclass.charSet)
AddWarning (parent, "CharSet is wrong: {0} != {1}", charSet, oclass.charSet);
if (layout != oclass.layout)
AddWarning (parent, "Layout is wrong: {0} != {1}", layout, oclass.layout);
if (interfaces != null || oclass.interfaces != null) {
if (interfaces == null)
interfaces = new XMLInterfaces ();
interfaces.CompareTo (doc, parent, oclass.interfaces);
counters.AddPartialToPartial (interfaces.Counters);
}
if (genericConstraints != null || oclass.genericConstraints != null) {
if (genericConstraints == null)
genericConstraints = new XMLGenericTypeConstraints ();
genericConstraints.CompareTo (doc, parent, oclass.genericConstraints);
counters.AddPartialToPartial (genericConstraints.Counters);
}
if (fields != null || oclass.fields != null) {
if (fields == null)
fields = new XMLFields ();
fields.CompareTo (doc, parent, oclass.fields);
counters.AddPartialToPartial (fields.Counters);
}
if (constructors != null || oclass.constructors != null) {
if (constructors == null)
constructors = new XMLConstructors ();
constructors.CompareTo (doc, parent, oclass.constructors);
counters.AddPartialToPartial (constructors.Counters);
}
if (properties != null || oclass.properties != null) {
if (properties == null)
properties = new XMLProperties ();
properties.CompareTo (doc, parent, oclass.properties);
counters.AddPartialToPartial (properties.Counters);
}
if (events != null || oclass.events != null) {
if (events == null)
events = new XMLEvents ();
events.CompareTo (doc, parent, oclass.events);
counters.AddPartialToPartial (events.Counters);
}
if (methods != null || oclass.methods != null) {
if (methods == null)
methods = new XMLMethods ();
methods.CompareTo (doc, parent, oclass.methods);
counters.AddPartialToPartial (methods.Counters);
}
if (nested != null || oclass.nested != null) {
XmlNode n = doc.CreateElement ("classes", null);
parent.AppendChild (n);
CompareTypes (n, oclass.nested);
}
AddCountersAttributes (parent);
}
public override void LoadData (XmlNode node)
{
if (node == null)
throw new ArgumentNullException ("node");
name = node.Attributes ["name"].Value;
type = node.Attributes ["type"].Value;
XmlAttribute xatt = node.Attributes ["base"];
if (xatt != null)
baseName = xatt.Value;
xatt = node.Attributes ["sealed"];
isSealed = (xatt != null && xatt.Value == "true");
xatt = node.Attributes ["abstract"];
isAbstract = (xatt != null && xatt.Value == "true");
xatt = node.Attributes["serializable"];
isSerializable = (xatt != null && xatt.Value == "true");
xatt = node.Attributes["charset"];
if (xatt != null)
charSet = xatt.Value;
xatt = node.Attributes["layout"];
if (xatt != null)
layout = xatt.Value;
XmlNode child = node.FirstChild;
if (child == null) {
// Console.Error.WriteLine ("Empty class {0} {1}", name, type);
return;
}
if (child.Name == "attributes") {
attributes = new XMLAttributes ();
attributes.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "interfaces") {
interfaces = new XMLInterfaces ();
interfaces.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "generic-type-constraints") {
genericConstraints = new XMLGenericTypeConstraints ();
genericConstraints.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "fields") {
fields = new XMLFields ();
fields.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "constructors") {
constructors = new XMLConstructors ();
constructors.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "properties") {
properties = new XMLProperties ();
properties.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "events") {
events = new XMLEvents ();
events.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "methods") {
methods = new XMLMethods ();
methods.LoadData (child);
child = child.NextSibling;
}
if (child != null && child.Name == "generic-parameters") {
// HACK: ignore this tag as it doesn't seem to
// add any value when checking for differences
return;
}
if (child == null)
return;
if (child.Name != "classes") {
Console.WriteLine ("name: {0} type: {1} {2}", name, type, child.NodeType);
throw new FormatException ("Expecting <classes>. Got <" + child.Name + ">");
}
nested = (XMLClass []) LoadRecursive (child.ChildNodes, typeof (XMLClass));
}