public override void Modified(XElement source, XElement target, ApiChanges diff)
{
// hack - there could be changes that we're not monitoring (e.g. attributes properties)
var output = Output;
State.Output = new StringWriter();
var sb = source.GetAttribute("base");
var tb = target.GetAttribute("base");
var rm = $"{State.Namespace}.{State.Type}: Modified base type: '{sb}' to '{tb}'";
State.LogDebugMessage($"Possible -r value: {rm}");
if (sb != tb &&
!State.IgnoreRemoved.Any(re => re.IsMatch(rm)) &&
!(State.IgnoreNonbreaking && IsBaseChangeCompatible(sb, tb)))
{
Formatter.BeginMemberModification(Output, "Modified base type");
var apichange = new ApiChange($"{State.Namespace}.{State.Type}", State).AppendModified(sb, tb, true);
Formatter.Diff(Output, apichange);
Formatter.EndMemberModification(Output);
}
ccomparer.Compare(source, target);
icomparer.Compare(source, target);
fcomparer.Compare(source, target);
pcomparer.Compare(source, target);
ecomparer.Compare(source, target);
mcomparer.Compare(source, target);
var si = source.Element("classes");
if (si != null)
{
var ti = target.Element("classes");
kcomparer = new NestedClassComparer(State);
State.Parent = State.Type;
kcomparer.Compare(si.Elements("class"), ti == null ? null : ti.Elements("class"));
State.Type = State.Parent;
}
var s = (Output as StringWriter).ToString();
State.Output = output;
if (s.Length > 0)
{
SetContext(target);
Formatter.BeginTypeModification(Output);
Output.WriteLine(s);
Formatter.EndTypeModification(Output);
}
}
public void AddedInner(XElement target)
{
SetContext(target);
if (target.IsTrue("serializable"))
{
Indent().WriteLine("[Serializable]");
}
var type = target.Attribute("type").Value;
if (type == "enum")
{
// check if [Flags] is present
var cattrs = target.Element("attributes");
if (cattrs != null)
{
foreach (var ca in cattrs.Elements("attribute"))
{
if (ca.GetAttribute("name") == "System.FlagsAttribute")
{
Indent().WriteLine("[Flags]");
break;
}
}
}
}
Indent().Write("public");
if (type != "enum")
{
bool seal = target.IsTrue("sealed");
bool abst = target.IsTrue("abstract");
if (seal && abst)
{
Output.Write(" static");
}
else if (seal && type != "struct")
{
Output.Write(" sealed");
}
else if (abst && type != "interface")
{
Output.Write(" abstract");
}
}
Output.Write(' ');
Output.Write(type);
Output.Write(' ');
Output.Write(target.GetAttribute("name"));
var baseclass = target.GetAttribute("base");
if ((type != "enum") && (type != "struct"))
{
if (baseclass != null)
{
if (baseclass == "System.Object")
{
// while true we do not need to be reminded every time...
baseclass = null;
}
else
{
Output.Write(" : ");
Output.Write(baseclass);
}
}
}
// interfaces on enums are "standard" not user provided - so we do not want to show them
if (type != "enum")
{
var i = target.Element("interfaces");
if (i != null)
{
var interfaces = new List <string> ();
foreach (var iface in i.Elements("interface"))
{
interfaces.Add(icomparer.GetDescription(iface));
}
Output.Write((baseclass == null) ? " : " : ", ");
Output.Write(String.Join(", ", interfaces));
}
}
Output.WriteLine(" {");
State.Indent++;
var t = target.Element("constructors");
if (t != null)
{
Indent().WriteLine("// constructors");
foreach (var ctor in t.Elements("constructor"))
{
ccomparer.Added(ctor, true);
}
}
t = target.Element("fields");
if (t != null)
{
if (type != "enum")
{
Indent().WriteLine("// fields");
}
else
{
SetContext(target);
}
foreach (var field in t.Elements("field"))
{
fcomparer.Added(field, true);
}
}
t = target.Element("properties");
if (t != null)
{
Indent().WriteLine("// properties");
foreach (var property in t.Elements("property"))
{
pcomparer.Added(property, true);
}
}
t = target.Element("events");
if (t != null)
{
Indent().WriteLine("// events");
foreach (var evnt in t.Elements("event"))
{
ecomparer.Added(evnt, true);
}
}
t = target.Element("methods");
if (t != null)
{
Indent().WriteLine("// methods");
foreach (var method in t.Elements("method"))
{
mcomparer.Added(method, true);
}
}
t = target.Element("classes");
if (t != null)
{
Output.WriteLine();
Indent().WriteLine("// inner types");
State.Parent = State.Type;
kcomparer = new NestedClassComparer(State);
foreach (var inner in t.Elements("class"))
{
kcomparer.AddedInner(inner);
}
State.Type = State.Parent;
}
State.Indent--;
Indent().WriteLine("}");
}
public NamespaceComparer(State state)
: base(state)
{
comparer = new ClassComparer(state);
}
