using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Runtime.CompilerServices;
|
using System.Xml.Serialization;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// This attribute is used to dynamically embed the properties of an object into another object.
|
/// </summary>
|
/// <remarks>
|
/// A property of type PT declared on a type DT decorated with this attribute will not be visible in reflection information (ITypeData) for DT.
|
/// Instead all properties declared on PT will be visible on DT as though they had been declared there.
|
/// </remarks>
|
[AttributeUsage(AttributeTargets.Property)]
|
public class EmbedPropertiesAttribute : Attribute
|
{
|
/// <summary>
|
/// When true, property name of the owning property is used as prefix for embedded properties. E.g., the name will be 'EmbeddedProperty.X'.
|
/// A prefix can help prevent name-clashing issues if multiple properties gets the same name.
|
/// </summary>
|
public bool PrefixPropertyName { get; set; } = true;
|
|
/// <summary>
|
/// Custom prefix for embedded properties. This will overwrite PrefixPropertyName.
|
/// A prefix can help prevent name-clashing issues if multiple properties gets the same name.
|
/// </summary>
|
public string Prefix { get; set; } = null;
|
}
|
|
//
|
// The code below implements the embedded member data dynamic reflection.
|
// It creates a wrapper around existing types and gives them an extra layer
|
// which contains the added properties.
|
//
|
class EmbeddedMemberData : IMemberData, IDynamicMemberData, IEmbeddedMemberData
|
{
|
public IMemberData OwnerMember => ownerMember;
|
public IMemberData InnerMember => innerMember;
|
readonly IMemberData ownerMember;
|
readonly IMemberData innerMember;
|
private readonly IEnumerable<object> additionalAttributes;
|
|
public ITypeData DeclaringType => ownerMember.DeclaringType;
|
public ITypeData TypeDescriptor => innerMember.TypeDescriptor;
|
public bool Writable => innerMember.Writable;
|
public bool Readable => innerMember.Readable;
|
|
public IEnumerable<object> Attributes => attributes ?? (attributes = loadAndTransformAttributes());
|
public string Name { get; }
|
|
public object GetValue(object owner)
|
{
|
var target = ownerMember.GetValue(owner);
|
if (target == null) return null;
|
return innerMember.GetValue(target);
|
}
|
|
public void SetValue(object owner, object value)
|
{
|
var target = ownerMember.GetValue(owner);
|
if (target == null) throw new NullReferenceException($"Embedded property object owner ('{ownerMember.Name}') is null.");
|
innerMember.SetValue(target, value);
|
}
|
public EmbeddedMemberData(IMemberData ownerMember, IMemberData innerMember, IEnumerable<object> additionalAttributes)
|
{
|
this.ownerMember = ownerMember;
|
this.innerMember = innerMember;
|
this.additionalAttributes = additionalAttributes;
|
var embed = ownerMember.GetAttribute<EmbedPropertiesAttribute>();
|
if (embed.PrefixPropertyName)
|
{
|
var prefix_name = embed.Prefix ?? ownerMember.Name;
|
Name = prefix_name + "." + this.innerMember.Name;
|
}
|
else
|
Name = this.innerMember.Name;
|
}
|
public override string ToString() => $"EmbMem:{Name}";
|
|
object[] attributes;
|
|
/// <summary>
|
/// Loads and transform the list of attributes.
|
/// Some attributes are sensitive to naming, the known ones are AvailableValuesAttribute,
|
/// SuggestedValueAttribute, and EnabledIf. Others might exist, but they are, for now, not supported.
|
/// When NoPrefix is set on EmbedProperties, then there is no issue, but with the prefix, those names also needs
|
/// to be transformed.
|
/// Additionally, there is some special behavior wanted for Display, for usability and to avoid name clashing:
|
/// - If a Display name/group is set on the owner property, that should turn into a group for the embedded properties.
|
/// - If there is no display name, use the prefix name for the group.
|
/// - If there is no prefix name, don't touch DisplayAttribute.
|
/// </summary>
|
object[] loadAndTransformAttributes()
|
{
|
|
string prefix_name = null;
|
|
var list = innerMember.Attributes.ToList();
|
|
var embed = ownerMember.GetAttribute<EmbedPropertiesAttribute>();
|
if (embed.PrefixPropertyName)
|
prefix_name = embed.Prefix ?? ownerMember.Name;
|
|
string[] pre_group1;
|
string pre_name;
|
double ownerOrder = -10000;
|
bool collapsed = false;
|
{
|
var owner_display = ownerMember.GetAttribute<DisplayAttribute>();
|
|
if (owner_display == null)
|
{
|
owner_display = new DisplayAttribute(embed.PrefixPropertyName ? ownerMember.Name : "");
|
pre_group1 = owner_display.Group;
|
pre_name = owner_display.Name;
|
}
|
else
|
{
|
collapsed = owner_display.Collapsed;
|
ownerOrder = owner_display.Order;
|
pre_group1 = owner_display.Group;
|
pre_name = owner_display.Name;
|
}
|
}
|
|
string name;
|
string[] post_group;
|
var d = list.OfType<DisplayAttribute>().FirstOrDefault();
|
if (d != null)
|
{
|
list.Remove(d); // need to re-add a new DisplayAttribute.
|
name = d.Name;
|
post_group = d.Group;
|
if (d.Collapsed)
|
collapsed = true;
|
}
|
else
|
{
|
name = Name;
|
post_group = Array.Empty<string>();
|
}
|
|
string[] prefixGroups;
|
if (embed.PrefixPropertyName == false && string.IsNullOrWhiteSpace(pre_name))
|
prefixGroups = Array.Empty<string>();
|
else
|
prefixGroups = new[] {pre_name};
|
|
var groups = pre_group1.Concat(prefixGroups).Concat(post_group).ToArray();
|
|
|
double order = -10000;
|
{
|
// calculate order:
|
// if owner order is set, add it to the display order.
|
if (d != null && d.Order != -10000.0)
|
{
|
order = d.Order;
|
if (ownerOrder != -10000.0)
|
{
|
// if an order is specified, add the two orders together.
|
// this makes sure that property groups can be arranged.
|
order += ownerOrder;
|
}
|
}
|
else
|
{
|
order = ownerOrder;
|
}
|
}
|
d = new DisplayAttribute(name, Groups: groups,
|
Description: d?.Description, Order: order, Collapsed: collapsed);
|
|
list.Add(d);
|
|
if (prefix_name != null)
|
{
|
// Transform properties that has issues with embedding.
|
for (var i = 0; i < list.Count; i++)
|
{
|
var item = list[i];
|
if (item is AvailableValuesAttribute avail)
|
{
|
list[i] = new AvailableValuesAttribute(prefix_name + "." + avail.PropertyName);
|
}
|
else if (item is SuggestedValuesAttribute sug)
|
{
|
list[i] = new SuggestedValuesAttribute(prefix_name + "." + sug.PropertyName);
|
}
|
else if (item is EnabledIfAttribute enabled)
|
{
|
list[i] = new EnabledIfAttribute(prefix_name + "." + enabled.PropertyName, enabled.Values)
|
{HideIfDisabled = enabled.HideIfDisabled};
|
}
|
}
|
}
|
|
return attributes = list.Concat(additionalAttributes ?? []).ToArray();
|
}
|
|
bool IDynamicMemberData.IsDisposed => OwnerMember is IDynamicMemberData dyn && dyn.IsDisposed;
|
}
|
|
class EmbeddedTypeData : ITypeData
|
{
|
IMemberData[] listedEmbeddedMembers;
|
|
public ITypeData BaseType { get; set; }
|
public bool CanCreateInstance => BaseType.CanCreateInstance;
|
public IEnumerable<object> Attributes => BaseType.Attributes;
|
public string Name => EmbeddedTypeDataProvider.exp + BaseType.Name;
|
public object CreateInstance(object[] arguments) => BaseType.CreateInstance(arguments);
|
public IMemberData GetMember(string name) => GetMembers().FirstOrDefault(x => x.Name == name);
|
|
public IEnumerable<IMemberData> GetMembers() => BaseType.GetMembers()
|
.Where(x => x.HasAttribute<EmbedPropertiesAttribute>() == false)
|
.Concat(listedEmbeddedMembers ??= ListEmbeddedMembers());
|
public override int GetHashCode() => BaseType.GetHashCode() * 86966513 + typeof(EmbeddedTypeData).GetHashCode();
|
public override bool Equals(object obj)
|
{
|
if(obj is EmbeddedTypeData e)
|
return e.BaseType == BaseType;
|
return false;
|
}
|
|
[ThreadStatic]
|
static HashSet<ITypeData> currentlyListing;
|
|
public IEnumerable<IMemberData> GetEmbeddingMembers()
|
{
|
foreach (var member in BaseType.GetMembers())
|
{
|
if (member.HasAttribute<EmbedPropertiesAttribute>())
|
{
|
yield return member;
|
}
|
}
|
}
|
|
internal IMemberData[] ListEmbeddedMembers()
|
{
|
if (currentlyListing == null)
|
currentlyListing = new HashSet<ITypeData>();
|
List<IMemberData> embeddedMembers = new List<IMemberData>();
|
if (currentlyListing.Contains(this))
|
return embeddedMembers.ToArray();
|
currentlyListing.Add(this);
|
|
foreach (var member in BaseType.GetMembers())
|
{
|
if (member.HasAttribute<EmbedPropertiesAttribute>())
|
{
|
var xmlIgnore = member.HasAttribute<XmlIgnoreAttribute>();
|
var members = member.TypeDescriptor.GetMembers();
|
foreach(var m in members)
|
{
|
if (m.HasAttribute<EmbedPropertiesAttribute>())
|
{
|
if (xmlIgnore == false)
|
xmlIgnore = m.HasAttribute<XmlIgnoreAttribute>();
|
members = EmbeddedTypeDataProvider.FromTypeData(member.TypeDescriptor).GetMembers();
|
break;
|
}
|
}
|
|
object[] additionalAttributes = xmlIgnore ? [new XmlIgnoreAttribute()] : [];
|
foreach (var innermember in members)
|
embeddedMembers.Add(new EmbeddedMemberData(member, innermember, additionalAttributes));
|
}
|
}
|
currentlyListing.Remove(this);
|
return embeddedMembers.ToArray();
|
}
|
public override string ToString() => $"EmbType:{Name}";
|
}
|
|
class EmbeddedTypeDataProvider : IStackedTypeDataProvider
|
{
|
public double Priority => 10.5;
|
internal const string exp = "emb:";
|
static ConditionalWeakTable<ITypeData, EmbeddedTypeData> internedValues = new ConditionalWeakTable<ITypeData, EmbeddedTypeData>();
|
static EmbeddedTypeData getOrCreate(ITypeData e) => internedValues.GetValue(e, t => t.GetMembers().Any(m => m.HasAttribute<EmbedPropertiesAttribute>()) ? new EmbeddedTypeData{BaseType = e} : null);
|
|
public static EmbeddedTypeData FromTypeData(ITypeData baseType) => getOrCreate(baseType);
|
|
public ITypeData GetTypeData(string identifier, TypeDataProviderStack stack)
|
{
|
if (identifier.StartsWith(exp))
|
{
|
var tp = TypeData.GetTypeData(identifier.Substring(exp.Length));
|
if (tp != null)
|
{
|
var embTp = FromTypeData(tp);
|
if (embTp != null)
|
return embTp;
|
return tp;
|
}
|
}
|
return null;
|
}
|
|
class KeyBox
|
{
|
public int Key { get; set; }
|
}
|
// this key table is used to keep track of the members of dynamic types.
|
// if the key has changed, then it means that the cache should be invalidated.
|
static ConditionalWeakTable<object, KeyBox> keyTable = new ConditionalWeakTable<object, KeyBox>();
|
|
public ITypeData GetTypeData(object obj, TypeDataProviderStack stack)
|
{
|
var typeData = stack.GetTypeData(obj);
|
var nowKey = DynamicMember.GetTypeDataKey(obj);
|
bool reload = false;
|
if (nowKey != 0)
|
{
|
if (keyTable.TryGetValue(obj, out var currentKey))
|
{
|
if (currentKey.Key != nowKey)
|
{
|
reload = true;
|
currentKey.Key = nowKey;
|
}
|
}
|
else
|
{
|
keyTable.Add(obj, new KeyBox(){Key = nowKey});
|
reload = true;
|
}
|
}
|
if (reload)
|
{
|
internedValues.Remove(typeData);
|
}
|
if (internedValues.TryGetValue(typeData, out EmbeddedTypeData val))
|
{
|
return val ?? typeData;
|
}
|
|
if (typeData.GetMembers().Any(x => x.HasAttribute<EmbedPropertiesAttribute>()))
|
return FromTypeData(typeData);
|
// assign null to the value.
|
return internedValues.GetValue(typeData, t => null) ?? typeData;
|
}
|
}
|
}
|
