/// <inheritdoc/>
protected override void OnSetup(Type type, ConfigValueAttribute attribute)
{
ConfigNodeAttribute node = type.GetCustomAttribute <ConfigNodeAttribute>();
Id = node?.Id ?? type.Name;
// there should only be 1 root node for one type
if (node != null)
{
IsRootNode = node.IsRoot;
ShouldSave = node.ShouldSave;
if (node.IsRoot)
{
AllowMultiple = node.AllowMultiple;
}
}
// if this is a member of some type
if (attribute != null)
{
FARLogger.AssertFormat(!string.IsNullOrEmpty(attribute.Name),
"Nested nodes required ConfigValue.Name to be set");
Name = attribute.Name;
}
// get all public fields
var fields = new HashSet <FieldInfo>(type.GetFields(PublicFlags));
// and add all the other fields that declare ConfigValueAttribute
fields.UnionWith(type.GetFieldsWithAttribute <ConfigValueAttribute>(flags: AllFlags)
.Select(pair => pair.Second));
// only get properties that declare ConfigValueAttribute
var properties = new List <PropertyInfo>(type.GetPropertiesWithAttribute <ConfigValueAttribute>(AllFlags)
.Select(pair => pair.Second));
FARLogger.TraceFormat("Found {0} fields and {1} properties in {2}",
fields.Count.ToString(),
properties.Count.ToString(),
type);
foreach (FieldInfo fi in fields)
{
SetupType(fi, fi.FieldType);
}
foreach (PropertyInfo pi in properties)
{
SetupType(pi, pi.PropertyType);
}
if (!Children.TryGetValue(type, out List <Type> list))
{
return;
}
foreach (Type subnode in list)
{
SetupType(null, subnode);
}
}
protected override void OnSetup(Type type, ConfigValueAttribute attribute)
{
ValueType = ReflectionUtils.ListType(ValueType) ?? ValueType;
if (attribute != null)
{
Name = attribute.Name;
}
ConfigNodeAttribute node = ValueType.GetCustomAttribute <ConfigNodeAttribute>();
NodeId ??= node?.Id;
}
public static ListValueReflection Create(
MemberInfo mi,
ConfigValueAttribute attribute = null,
Type valueType = null
)
{
var reflection = new ListValueReflection();
if (valueType != null)
{
reflection.ValueType = valueType;
}
return(Factory(reflection, mi, attribute));
}
private void Setup(MemberInfo mi, Type type, ConfigValueAttribute attribute = null)
{
// try and get the attribute since it will override some of the options
attribute ??= type?.GetCustomAttribute <ConfigValueAttribute>();
DeclaringType = mi?.DeclaringType;
// if name has not been yet setup, use the name from the attribute if it was specified, otherwise default to the member name
Name ??= attribute?.Name ?? mi?.Name;
// if value type has not been setup, try to deduce it from the member type, then try to use type from the attribute or fallback to the provided type
ValueType ??= ReflectionUtils.ConfigValueType(type) ?? attribute?.Type ?? type;
// delegate the remaining setup to children
OnSetup(type, attribute);
}
private void SetupType(MemberInfo mi, Type memberType)
{
// if ignored, nothing to do
if (mi?.GetCustomAttribute <ConfigValueIgnoreAttribute>() != null)
{
return;
}
// check if the type is a node and contains ConfigValueAttribute
ConfigNodeAttribute node = memberType.GetCustomAttribute <ConfigNodeAttribute>();
ConfigValueAttribute value = mi?.GetCustomAttribute <ConfigValueAttribute>();
// try to get the list value type
Type listValueType = ReflectionUtils.ListType(ReflectionUtils.ConfigValueType(memberType) ?? memberType);
if (listValueType != null)
{
// is a list
var reflection = ListValueReflection.Create(mi, value, listValueType);
ListValues.Add(reflection);
FARLogger.TraceFormat("Added list value '{1} -> <{0}, {2}>'",
reflection.Name ?? "{null}",
reflection.NodeId ?? "{null}",
reflection.ValueType);
}
else if (node == null)
{
// not a node or a list -> simple value
ValueReflection reflection = Create(mi, value);
Values.Add(reflection);
FARLogger.TraceFormat("Added value '{0} -> {1}'", reflection.Name, reflection.ValueType);
}
else
{
// ConfigValue name
string name = value?.Name;
// get clone or create new reflection for the type
NodeReflection nodeReflection = GetReflection(memberType, true, name, mi);
Nodes.Add(nodeReflection);
FARLogger.TraceFormat("Added node '{1} -> <{0}, {2}>'",
name ?? "{null}",
nodeReflection.Id,
nodeReflection.ValueType);
}
}
/// <summary>
/// A factory method for value reflections since virtual methods cannot be called in constructors
/// </summary>
/// <param name="reflection">the reflection to setup</param>
/// <param name="mi">member info this reflection will use</param>
/// <param name="attribute">optional attribute of the field/property, if null will try to get it automatically</param>
/// <typeparam name="T">child class of ValueReflection</typeparam>
/// <returns>reflection ready to use</returns>
protected static T Factory <T>(T reflection, MemberInfo mi, ConfigValueAttribute attribute = null)
where T : ValueReflection
{
// mi may be null when reflected value is not a member of a type
if (mi is null)
{
reflection.Info = reflection.ValueType is null ? null : new SingletonMember(reflection.ValueType);
}
else
{
reflection.Info = SetupInfo(mi);
}
// this involves a virtual call so cannot be used in constructors
// if mi is null, use existing value type
reflection.Setup(mi, reflection.Info?.ValueType ?? reflection.ValueType, attribute);
return(reflection);
}
/// <summary>
/// Finalize this reflection setup
/// </summary>
/// <param name="type">Type of this reflection</param>
/// <param name="attribute">ConfigValueAttribute for this reflection, null if not found</param>
protected virtual void OnSetup(Type type, ConfigValueAttribute attribute)
{
}
public static ValueReflection Create(MemberInfo mi, ConfigValueAttribute attribute = null)
{
return(Factory(new ValueReflection(), mi, attribute));
}
