public XPathTypeNode GetNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context)
{
if ((parent==null) && (memberInfo==null))
return GetRootNode(node, context);
return new XPathQueryableNode(node, memberInfo, parent, context);
}
public XPathTypeNode Copy(XPathTypeContext context)
{
XPathTypeNode ret = Clone();
ret._Context = context;
return(ret);
}
internal XPathTypeNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context)
{
Debug.Assert(context!=null);
if (context==null)
throw new ArgumentNullException("context");
Debug.Assert(node!=null);
if (node==null)
throw new ArgumentNullException("node");
_Node=node;
_MemberInfo=memberInfo;
_Parent=parent;
_Context=context;
// Initialize optional external metadata holding types
foreach (MetadataTypeAttribute mta in node.GetCustomAttributes(typeof(MetadataTypeAttribute), true))
_MetadataNodes=new Type[] { node, mta.MetadataClassType };
if (_MetadataNodes==null)
_MetadataNodes=new Type[] { node };
if (memberInfo!=null)
{
if (parent!=null)
_MetadataMemberInfos=parent.MetadataNodes
.SelectMany<Type, MemberInfo>(t => t.GetMember(memberInfo.Name, memberInfo.MemberType, BindingFlags.Instance | BindingFlags.Public))
.ToArray<MemberInfo>();
else
_MetadataMemberInfos=new MemberInfo[] { memberInfo };
}
}
/// <summary>Creates an <see cref="Expression" /> from the current node and the specified <paramref name="parameter" />.</summary>
/// <param name="parameter">A parameter that represents an instance of the root node, which is the furthest <see cref="Parent" /> from the current node.</param>
/// <param name="expectedType">The type that the returned expression is expected to represent.</param>
/// <param name="expressionCreator">A custom function that should be applied to the returned expression.</param>
/// <returns>The expression that gives access to the current node.</returns>
public Expression CreateExpression(ParameterExpression parameter, Type expectedType = null, Func <Expression, ParameterExpression, Expression> expressionCreator = null)
{
LinkedList <XPathTypeNode> path = GetNodePath();
path.RemoveFirst(); // This is the root, represented by the parameter
XPathTypeNode node = path.First.Value;
path.RemoveFirst();
return(node.CreateNodeExpression(parameter, path, expectedType, expressionCreator, new Stack <ParameterExpression>()));
}
internal protected override Expression CreateNodeExpression(Expression baseExpression, LinkedList <XPathTypeNode> path, Type expectedType, Func <Expression, ParameterExpression, Expression> expressionCreator, Stack <ParameterExpression> innerParams)
{
Expression enuex = Expression.PropertyOrField(baseExpression, MemberInfo.Name);
LambdaExpression oplex = null;
ParameterExpression param = Expression.Parameter(Type);
if (path.First == null)
{
if ((expressionCreator == null) && (innerParams.Count > 0))
{
throw new InvalidOperationException("Trying to create an expression to an element that is inside a collection.");
}
Expression select = (expressionCreator != null ? param : baseExpression);
if (ValueMemberInfo != null)
{
select = Expression.PropertyOrField(param, ValueMemberInfo.Name);
}
//select=GetSynonymExpression((MemberExpression)select, expectedType);
// We only want an expression to the collection
if (expressionCreator == null)
{
return(select);
}
oplex = Expression.Lambda(expressionCreator(select, param), param);
}
else
{
innerParams.Push(param);
XPathTypeNode node = path.First.Value;
path.RemoveFirst();
oplex = Expression.Lambda(node.CreateNodeExpression(param, path, expectedType, expressionCreator, innerParams), param);
}
return(Expression.Call(
typeof(Enumerable),
"Any",
new Type[] { Type },
enuex,
oplex
));
}
public virtual XPathTypeNode Clone()
{
var ret = new XPathTypeNode();
ret._AttributeChildrenNodes = AttributeChildrenNodes;
ret._Context = _Context;
ret._ElementChildrenNodes = ElementChildrenNodes;
ret._IgnoredChildrenNodes = IgnoredChildrenNodes;
ret._MemberInfo = _MemberInfo;
ret._MetadataMemberInfos = _MetadataMemberInfos;
ret._MetadataNodes = _MetadataNodes;
ret._Node = _Node;
ret._NodeAttributes = NodeAttributes.ToList <Attribute>();
ret._Parent = _Parent;
ret._ValueMemberInfo = ValueMemberInfo;
return(ret);
}
internal XPathTypeNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context)
{
Debug.Assert(context != null);
if (context == null)
{
throw new ArgumentNullException("context");
}
Debug.Assert(node != null);
if (node == null)
{
throw new ArgumentNullException("node");
}
_Node = node;
_MemberInfo = memberInfo;
_Parent = parent;
_Context = context;
// Initialize optional external metadata holding types
foreach (MetadataTypeAttribute mta in node.GetCustomAttributes(typeof(MetadataTypeAttribute), true))
{
_MetadataNodes = new Type[] { node, mta.MetadataClassType }
}
;
if (_MetadataNodes == null)
{
_MetadataNodes = new Type[] { node }
}
;
if (memberInfo != null)
{
if (parent != null)
{
_MetadataMemberInfos = parent.MetadataNodes
.SelectMany <Type, MemberInfo>(t => t.GetMember(memberInfo.Name, memberInfo.MemberType, BindingFlags.Instance | BindingFlags.Public))
.ToArray <MemberInfo>();
}
else
{
_MetadataMemberInfos = new MemberInfo[] { memberInfo }
};
}
}
public XPathTypeNode GetNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context)
{
if ((parent==null) && (memberInfo==null))
return GetRootNode(node, context);
if (node!=typeof(string)) // string implements IEnumerable<char>
{
Type entype=node.GetInterface("IEnumerable`1");
if (entype!=null)
{
Debug.Assert(entype.IsGenericType);
Type[] intypes=entype.GetGenericArguments();
Debug.Assert(intypes.Length==1);
return new XPathTypeEnumerableNode(intypes[0], memberInfo, parent, context);
}
}
return new XPathTypeNode(node, memberInfo, parent, context);
}
public XPathTypeNode GetNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context)
{
if ((parent == null) && (memberInfo == null))
{
return(GetRootNode(node, context));
}
if (node != typeof(string)) // string implements IEnumerable<char>
{
Type entype = node.GetInterface("IEnumerable`1");
if (entype != null)
{
Debug.Assert(entype.IsGenericType);
Type[] intypes = entype.GetGenericArguments();
Debug.Assert(intypes.Length == 1);
return(new XPathTypeEnumerableNode(intypes[0], memberInfo, parent, context));
}
}
return(new XPathTypeNode(node, memberInfo, parent, context));
}
internal protected virtual Expression CreateNodeExpression(Expression baseExpression, LinkedList <XPathTypeNode> path, Type expectedType, Func <Expression, ParameterExpression, Expression> expressionCreator, Stack <ParameterExpression> innerParams)
{
Expression ret = Expression.PropertyOrField(baseExpression, MemberInfo.Name);
if (path.First == null)
{
if (ValueMemberInfo != null)
{
ret = Expression.PropertyOrField(ret, ValueMemberInfo.Name);
}
ret = GetSynonymExpression((MemberExpression)ret, expectedType);
if ((expressionCreator == null) && (innerParams.Count > 0))
{
throw new InvalidOperationException("Trying to create an expression to an element that is inside a collection.");
}
ParameterExpression p = null;
if (innerParams.Count > 0)
{
p = innerParams.Pop();
}
if (expressionCreator != null)
{
return(expressionCreator(ret, p));
}
return(ret);
}
XPathTypeNode node = path.First.Value;
path.RemoveFirst();
return(node.CreateNodeExpression(ret, path, expectedType, expressionCreator, innerParams));
}
internal void MoveTo(XPathTypeNode node)
{
_Current=node;
}
protected virtual void GetChildren()
{
if ((_AttributeChildrenNodes==null) || (_ElementChildrenNodes==null) || (_IgnoredChildrenNodes==null))
{
// Attributes simple types dont't have children nodes
if (
(NodeType==XmlNodeType.Attribute) ||
(Type.GetTypeCode(_Node)!=TypeCode.Object)
)
{
_AttributeChildrenNodes=new XPathTypeNode[0];
_ElementChildrenNodes=new XPathTypeNode[0];
_IgnoredChildrenNodes=new XPathTypeNode[0];
return;
}
var ac=new List<XPathTypeNode>();
var ec=new List<XPathTypeNode>();
var ic=new List<XPathTypeNode>();
foreach (MemberInfo mi in _Node.GetMembers(BindingFlags.Instance | BindingFlags.Public))
{
Type type=GetMemberType(mi);
if (type==null)
continue;
XPathTypeNode node=_Context.NodeProvider.GetNode(type, mi, this, _Context);
// XmlIgnore ?
if (node.NodeAttributes.Any<Attribute>(a => a is XmlIgnoreAttribute))
{
ic.Add(node);
continue;
}
// XmlText ?
if (node.NodeAttributes.Any<Attribute>(a => a is XmlTextAttribute))
{
_ValueMemberInfo=mi;
continue;
}
switch (node.NodeType)
{
case XmlNodeType.Attribute:
ac.Add(node);
break;
case XmlNodeType.Element:
ec.Add(node);
break;
}
}
_AttributeChildrenNodes=ac.ToArray<XPathTypeNode>();
_ElementChildrenNodes=ec.OrderBy<XPathTypeNode, int>(n => n.Order).ToArray<XPathTypeNode>();
_IgnoredChildrenNodes=ic.ToArray<XPathTypeNode>();
}
}
/// <summary>Creates a new instance of the <see cref="XPathTypeRootNode" /> class that will act as a root node.</summary>
/// <param name="root"></param>
/// <param name="context"></param>
internal protected XPathTypeRootNode(Type root, XPathTypeContext context):
base(root, context)
{
_ElementChildrenNodes=new XPathTypeNode[] { context.NodeProvider.GetNode(Node, null, this, Context) };
}
internal XPathTypeEnumerableNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context) :
base(node, memberInfo, parent, context)
{
}
protected virtual void GetChildren()
{
if ((_AttributeChildrenNodes == null) || (_ElementChildrenNodes == null) || (_IgnoredChildrenNodes == null))
{
// Attributes simple types dont't have children nodes
if (
(NodeType == XmlNodeType.Attribute) ||
(Type.GetTypeCode(_Node) != TypeCode.Object)
)
{
_AttributeChildrenNodes = new XPathTypeNode[0];
_ElementChildrenNodes = new XPathTypeNode[0];
_IgnoredChildrenNodes = new XPathTypeNode[0];
return;
}
var ac = new List <XPathTypeNode>();
var ec = new List <XPathTypeNode>();
var ic = new List <XPathTypeNode>();
foreach (MemberInfo mi in _Node.GetMembers(BindingFlags.Instance | BindingFlags.Public))
{
Type type = GetMemberType(mi);
if (type == null)
{
continue;
}
XPathTypeNode node = _Context.NodeProvider.GetNode(type, mi, this, _Context);
// XmlIgnore ?
if (node.NodeAttributes.Any <Attribute>(a => a is XmlIgnoreAttribute))
{
ic.Add(node);
continue;
}
// XmlText ?
if (node.NodeAttributes.Any <Attribute>(a => a is XmlTextAttribute))
{
_ValueMemberInfo = mi;
continue;
}
switch (node.NodeType)
{
case XmlNodeType.Attribute:
ac.Add(node);
break;
case XmlNodeType.Element:
ec.Add(node);
break;
}
}
_AttributeChildrenNodes = ac.ToArray <XPathTypeNode>();
_ElementChildrenNodes = ec.OrderBy <XPathTypeNode, int>(n => n.Order).ToArray <XPathTypeNode>();
_IgnoredChildrenNodes = ic.ToArray <XPathTypeNode>();
}
}
internal void MoveTo(XPathTypeNode node)
{
_Current = node;
}
/// <summary>Creates a new instance of the <see cref="XPathTypeRootNode" /> class that will act as a root node.</summary>
/// <param name="root"></param>
/// <param name="context"></param>
internal protected XPathTypeRootNode(Type root, XPathTypeContext context) :
base(root, context)
{
_ElementChildrenNodes = new XPathTypeNode[] { context.NodeProvider.GetNode(Node, null, this, Context) };
}
internal XPathTypeEnumerableNode(Type node, MemberInfo memberInfo, XPathTypeNode parent, XPathTypeContext context):
base(node, memberInfo, parent, context)
{
}
public virtual XPathTypeNode Clone()
{
var ret=new XPathTypeNode();
ret._AttributeChildrenNodes=AttributeChildrenNodes;
ret._Context=_Context;
ret._ElementChildrenNodes=ElementChildrenNodes;
ret._IgnoredChildrenNodes=IgnoredChildrenNodes;
ret._MemberInfo=_MemberInfo;
ret._MetadataMemberInfos=_MetadataMemberInfos;
ret._MetadataNodes=_MetadataNodes;
ret._Node=_Node;
ret._NodeAttributes=NodeAttributes.ToList<Attribute>();
ret._Parent=_Parent;
ret._ValueMemberInfo=ValueMemberInfo;
return ret;
}
