using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Globalization;
|
using System.Linq;
|
using System.Xml.Linq;
|
using System.Xml.Serialization;
|
|
namespace OpenTap.Package;
|
|
internal class PluginFileSerializerPlugin : TapSerializerPlugin
|
{
|
private bool Deserialize2(XElement node, ITypeData t, Action<object> setter)
|
{
|
if (!(node.Name.LocalName == "Plugin" && t.IsA(typeof(PluginFile))))
|
return false;
|
var plugin = new PluginFile();
|
foreach (var attr in node.Attributes())
|
{
|
switch (attr.Name.LocalName)
|
{
|
case "Type": plugin.Type = attr.Value; break;
|
case "BaseType": plugin.BaseType = attr.Value; break;
|
}
|
}
|
|
var manufacturersModels = new Dictionary<string, List<string>>();
|
foreach (var elm in node.Elements())
|
{
|
switch (elm.Name.LocalName)
|
{
|
case "Name": plugin.Name = elm.Value; break;
|
case "Order": plugin.Order = double.Parse(elm.Value, CultureInfo.InvariantCulture); break;
|
case "Browsable": plugin.Browsable = bool.Parse(elm.Value); break;
|
case "Description": plugin.Description = elm.Value; break;
|
case "Collapsed": plugin.Collapsed = bool.Parse(elm.Value); break;
|
case "Groups":
|
if (elm.HasElements)
|
Serializer.Deserialize(elm, o => plugin.Groups = o as string[], typeof(string[]));
|
else plugin.Groups = [];
|
break;
|
case "Manufacturer":
|
var manufacturerName = elm.Attribute("Name").Value;
|
var models = elm.Elements().Select(x => x.Value).ToArray();
|
var lst = manufacturersModels.GetOrCreateValue(manufacturerName, _ => new());
|
lst.AddRange(models);
|
break;
|
}
|
}
|
plugin.SupportedModels =
|
manufacturersModels.Select(kvp => new SupportedModelsAttribute(kvp.Key, kvp.Value.ToArray())).ToArray();
|
|
setter.Invoke(plugin);
|
return true;
|
}
|
public override bool Deserialize(XElement node, ITypeData t, Action<object> setter)
|
{
|
// This is a workaround for a bug in older versions of OpenTAP which causes issues in upgrade scenarios.
|
// When updating OpenTAP itself while running isolated, older versions of OpenTAP will detect that
|
// the new version contains a new serializer plugin, which it will attempt to load. However,
|
// this new serializer plugin depends on a newer version of `OpenTap.dll`, so using it will cause type load exceptions at runtime.
|
try
|
{
|
return Deserialize2(node, t, setter);
|
}
|
catch (TypeLoadException)
|
{
|
// Fall back to the previous serializer logic. This should not cause issues since it will only happen
|
// when this dll was loaded by an older version of OpenTAP
|
return false;
|
}
|
}
|
|
public static string SerializeDoubleWithRoundtrip(double d)
|
{
|
// It was decided to use R instead of G17 for readability, although G17 is slightly faster.
|
// however, there is a bug in "R" formatting on some .NET versions, that means that
|
// roundtrip actually does not work.
|
// See section "Note to Callers:" at https://msdn.microsoft.com/en-us/library/kfsatb94(v=vs.110).aspx
|
// so here we format and then parse back to see if it can actually roundtrip.
|
// if not, we format with G17.
|
var d_str = d.ToString("R", CultureInfo.InvariantCulture);
|
var d_re = double.Parse(d_str, CultureInfo.InvariantCulture);
|
if (d_re != d)
|
// round trip not possible with R, use G17 instead.
|
d_str = d.ToString("G17", CultureInfo.InvariantCulture);
|
return d_str;
|
}
|
|
public override bool Serialize(XElement node, object obj, ITypeData expectedType)
|
{
|
if (expectedType.IsA(typeof(PluginFile)) == false) return false;
|
foreach (IMemberData prop in expectedType.GetMembers().Where(s => !s.HasAttribute<XmlIgnoreAttribute>()))
|
{
|
object val = prop.GetValue(obj);
|
string name = prop.Name;
|
var defaultValueAttr = prop.GetAttribute<DefaultValueAttribute>();
|
if (defaultValueAttr != null)
|
{
|
if (Object.Equals(defaultValueAttr.Value, val))
|
continue;
|
if (defaultValueAttr.Value == null)
|
{
|
if (val is IEnumerable enu && enu.IsEnumerableEmpty()) // the value is an empty IEnumerable
|
{
|
continue; // We take an empty IEnumerable to be the same as null
|
}
|
}
|
}
|
|
switch (name)
|
{
|
case nameof(PluginFile.Type):
|
case nameof(PluginFile.BaseType):
|
node.SetAttributeValue(name, val);
|
break;
|
case nameof(PluginFile.Order):
|
node.Add(new XElement(name)
|
{
|
Value = SerializeDoubleWithRoundtrip((double)val),
|
});
|
break;
|
case nameof(PluginFile.Name):
|
case nameof(PluginFile.Browsable):
|
case nameof(PluginFile.Description):
|
case nameof(PluginFile.Collapsed):
|
node.Add(new XElement(name)
|
{
|
Value = val?.ToString() ?? ""
|
});
|
break;
|
case nameof(PluginFile.Groups):
|
var lst = new XElement("Groups");
|
if (val is string[] strs)
|
{
|
foreach (var str in strs)
|
{
|
lst.Add(new XElement("String")
|
{
|
Value = str
|
});
|
}
|
}
|
node.Add(lst);
|
break;
|
case nameof(PluginFile.SupportedModels):
|
if (val is SupportedModelsAttribute[] attrs)
|
{
|
var grp = attrs.GroupBy(x => x.Manufacturer);
|
foreach (var g in grp)
|
{
|
var man = new XElement("Manufacturer");
|
man.SetAttributeValue("Name", g.Key);
|
foreach (var model in g.SelectMany(x => x.Models))
|
{
|
var elm = new XElement("Model")
|
{
|
Value = model
|
};
|
man.Add(elm);
|
}
|
|
node.Add(man);
|
}
|
}
|
|
break;
|
}
|
}
|
|
return true;
|
}
|
}
|
