/// <summary>
/// Process the annotated field and set the values from the configuration attributes.
/// </summary>
/// <typeparam name="T">Target Instance type</typeparam>
/// <param name="node">Configuration Node</param>
/// <param name="target">Target Type instance.</param>
/// <param name="field">Property to update</param>
/// <param name="attr">Config attribute annotation</param>
/// <returns>Updated Target Type instance.</returns>
private static T ProcessField <T>(ConfigPathNode node, T target, FieldInfo field, ConfigAttribute attr, List <string> valuePaths)
{
string pname = attr.Name;
if (String.IsNullOrWhiteSpace(pname))
{
pname = field.Name;
}
string value = null;
if (!String.IsNullOrWhiteSpace(attr.Path))
{
AbstractConfigNode nnode = node.Find(attr.Path);
if (nnode != null && nnode.GetType() == typeof(ConfigPathNode))
{
node = (ConfigPathNode)nnode;
}
else
{
node = null;
}
}
if (node != null)
{
ConfigAttributesNode pnode = node.GetAttributes();
if (pnode != null)
{
ConfigValueNode vn = pnode.GetValue(pname);
if (vn != null)
{
value = vn.GetValue();
}
if (valuePaths != null)
{
valuePaths.Add(pnode.GetSearchPath());
}
}
}
if (!String.IsNullOrWhiteSpace(value))
{
object v = GetValue <T>(pname, value, attr.Function, field.FieldType, target, attr.Required);
if (v != null)
{
TypeUtils.CallSetter(field, target, v);
}
}
else if (attr.Required)
{
throw AnnotationProcessorException.Throw(target.GetType(), pname);
}
return(target);
}
/// <summary>
/// Process the annotated property and set the values from the configuration parameters.
/// </summary>
/// <typeparam name="T">Target Instance type</typeparam>
/// <param name="node">Configuration Node</param>
/// <param name="target">Target Type instance.</param>
/// <param name="property">Property to update</param>
/// <param name="param">Config param annotation</param>
/// <returns>Updated Target Type instance.</returns>
private static T ProcessProperty <T>(ConfigPathNode node, T target, PropertyInfo property, ConfigParam param, List <string> valuePath)
{
string pname = param.Name;
if (String.IsNullOrWhiteSpace(pname))
{
pname = property.Name;
}
string value = null;
if (!String.IsNullOrWhiteSpace(param.Path))
{
AbstractConfigNode nnode = node.Find(param.Path);
if (nnode != null && nnode.GetType() == typeof(ConfigPathNode))
{
node = (ConfigPathNode)nnode;
}
else
{
node = null;
}
}
if (node != null)
{
ConfigParametersNode pnode = node.GetParameters();
if (pnode != null)
{
ConfigValueNode vn = pnode.GetValue(pname);
if (vn != null)
{
value = vn.GetValue();
}
if (valuePath != null)
{
valuePath.Add(pnode.GetSearchPath());
}
}
}
if (!String.IsNullOrWhiteSpace(value))
{
object v = GetValue <T>(pname, value, param.Function, property.PropertyType, target, param.Required);
if (v != null)
{
property.SetValue(target, v);
}
}
else if (param.Required)
{
throw AnnotationProcessorException.Throw(target.GetType(), pname);
}
return(target);
}
private static object GetValue <T>(string field, string value, Type function, Type valueType, T target, bool required)
{
object v = null;
if (function != null)
{
v = TransformerHelper.Transform(function, value);
}
else
{
v = ReflectionUtils.ConvertFromString(valueType, value);
}
if (v == null && required)
{
throw AnnotationProcessorException.Throw(target.GetType(), field);
}
return(v);
}
/// <summary>
/// Process the annotated field and set the values from the configuration value.
/// </summary>
/// <typeparam name="T">Target Instance type</typeparam>
/// <param name="node">Configuration Node</param>
/// <param name="target">Target Type instance.</param>
/// <param name="field">Property to update</param>
/// <param name="configValue">Config value annotation</param>
/// <returns>Updated Target Type instance.</returns>
private static T ProcessField <T>(ConfigPathNode node, T target, FieldInfo field, ConfigValue configValue, List <string> valuePaths)
{
string pname = configValue.Name;
if (String.IsNullOrWhiteSpace(pname))
{
pname = field.Name;
}
string value = null;
if (!String.IsNullOrWhiteSpace(configValue.Path))
{
AbstractConfigNode nnode = node.Find(configValue.Path);
if (nnode != null && nnode.GetType() == typeof(ConfigPathNode))
{
node = (ConfigPathNode)nnode;
}
else
{
node = null;
}
}
if (node != null)
{
AbstractConfigNode cnode = node.GetChildNode(pname);
if (cnode != null)
{
if (valuePaths != null)
{
valuePaths.Add(cnode.GetSearchPath());
}
if (cnode.GetType() == typeof(ConfigValueNode))
{
ConfigValueNode vn = (ConfigValueNode)cnode;
if (vn != null)
{
value = vn.GetValue();
}
if (!String.IsNullOrWhiteSpace(value))
{
object v = GetValue <T>(pname, value, configValue.Function, field.FieldType, target, configValue.Required);
if (v != null)
{
TypeUtils.CallSetter(field, target, v);
}
}
}
else
{
if (ReflectionUtils.IsSubclassOfRawGeneric(field.FieldType, typeof(List <>)))
{
if (cnode.GetType() == typeof(ConfigListValueNode))
{
ConfigListValueNode configList = (ConfigListValueNode)cnode;
List <string> values = configList.GetValueList();
if (values != null)
{
Type inner = field.FieldType.GetGenericArguments()[0];
object v = ReflectionUtils.ConvertListFromStrings(inner, values);
if (v != null)
{
TypeUtils.CallSetter(field, target, v);
}
}
}
}
else if (ReflectionUtils.IsSubclassOfRawGeneric(field.FieldType, typeof(HashSet <>)))
{
if (cnode.GetType() == typeof(ConfigListValueNode))
{
ConfigListValueNode configList = (ConfigListValueNode)cnode;
List <string> values = configList.GetValueList();
if (values != null)
{
Type inner = field.FieldType.GetGenericArguments()[0];
object v = ReflectionUtils.ConvertSetFromStrings(inner, values);
if (v != null)
{
TypeUtils.CallSetter(field, target, v);
}
}
}
}
}
}
}
object ov = TypeUtils.CallGetter(field, target);
if (ov == null && configValue.Required)
{
throw AnnotationProcessorException.Throw(target.GetType(), pname);
}
return(target);
}
