public static ChainMemberNode CloneChainMemberNode(this ChainMemberNode node, ChainNode parent)
{
var child = new ChainMemberNode(node.Type, node.Expression, /* node.MemberInfo,*/ node.MemberName, /*node.ChainMemberNodeExpressionType,*/ node.IsEnumerable, parent);
parent.Children.Add(node.MemberName, child);
return(child);
}
private static int AddLevelRecursive(ChainNode root, ChainMemberNode[] parents, int number, Expression inExpression, out Expression outExpression)
{
var @value = number;
var node = parents.Length == 0 ? root : parents[parents.Length - 1];
outExpression = null;
foreach (var childPair in node.Children)
{
var memberNode = childPair.Value;
var modifiedParents = new ChainMemberNode[parents.Length + 1];
parents.CopyTo(modifiedParents, 0);
modifiedParents[parents.Length] = memberNode;
if (memberNode.Children.Count != 0)
{
@value = AddLevelRecursive(root, modifiedParents, @value, inExpression, out outExpression);
inExpression = outExpression;
}
else
{
@value = AddMember(root, modifiedParents, @value, inExpression, out outExpression);
inExpression = outExpression;
}
}
return(@value);
}
public static ChainMemberNode AddChild(this ChainNode node, FieldInfo fieldInfo)
{
var expression = node.Type.CreateFieldLambda(fieldInfo);
var child = new ChainMemberNode(fieldInfo.FieldType, expression, fieldInfo.Name, isEnumerable: false, node);
node.Children.Add(fieldInfo.Name, child);
return(child);
}
public static ChainMemberNode AddChild(this ChainNode node, PropertyInfo propertyInfo)
{
var expression = node.Type.CreatePropertyLambda(propertyInfo);
var child = new ChainMemberNode(propertyInfo.PropertyType, expression, propertyInfo.Name, isEnumerable: false, node);
node.Children.Add(propertyInfo.Name, child);
return(child);
}
public void Parse <TThenEntity, TEntity>(Expression <Func <TThenEntity, TEntity> > navigationExpression, bool changeCurrenNode, string memberName)
{
var node = AddIfAbsent(CurrentNode, navigationExpression, memberName, typeof(TEntity), null, false);
if (changeCurrenNode)
{
CurrentNode = node;
}
}
private static ChainMemberNode AddIfAbsent(
ChainNode parent,
LambdaExpression lambdaExpression,
string memberName,
Type navigationType,
Type navigationEnumerableType,
bool isEnumerable
)
{
var dictionary = parent.Children;
if (memberName != null)
{
if (!dictionary.TryGetValue(memberName, out ChainMemberNode node))
{
node = new ChainMemberNode(navigationType, lambdaExpression, memberName, isEnumerable, parent);
dictionary.Add(memberName, node);
}
return(node);
}
else
{
if (lambdaExpression.Body is MemberExpression)
{
var memberInfo = ((MemberExpression)lambdaExpression.Body).Member;
var name = memberInfo.Name;
if (!dictionary.TryGetValue(name, out ChainMemberNode node))
{
node = new ChainMemberNode(navigationType, lambdaExpression, name, isEnumerable, parent);
dictionary.Add(name, node);
}
return(node);
}
else if (lambdaExpression.Body is MethodCallExpression)
{
var methodInfo = ((MethodCallExpression)lambdaExpression.Body).Method;
var name = methodInfo.Name;
if (!dictionary.TryGetValue(name, out ChainMemberNode node))
{
node = new ChainMemberNode(navigationType, lambdaExpression, name, isEnumerable, parent);
dictionary.Add(name, node);
}
return(node);
}
else
{
throw new NotSupportedException("Not supported type of expression: neither member, neither method call");
}
}
}
public static Include <T> ComposeInclude <T>(this ChainNode root)
{
var parents = new ChainMemberNode[0];
var entityType = root.Type;
Type rootChainType = typeof(Chain <>).MakeGenericType(entityType);
ParameterExpression tParameterExpression = Expression.Parameter(rootChainType, "t");
int number = AddLevelRecursive(root, parents, 0, tParameterExpression, out Expression outExpression);
Include <T> @destination = null;
if (outExpression != null)
{
var lambdaExpression = Expression.Lambda <Include <T> >(outExpression, new[] { tParameterExpression });
@destination = lambdaExpression.Compile();
}
return(@destination);
}
public static ChainNode FindLinkedRootPath(ChainMemberNode node) => TreeExtensions.FindLinkedRootPath(meta, node);
public static bool FindNode(ChainNode root, string[] path, out ChainMemberNode node) => TreeExtensions.FindNode(meta, root, path, out node);
public void ParseRootEnumerable <TEntity>(Expression <Func <TRootEntity, IEnumerable <TEntity> > > navigationExpression, string memberName)
{
var node = AddIfAbsent(Root, navigationExpression, memberName, typeof(TEntity), typeof(IEnumerable <TEntity>), true);
CurrentNode = node;
}
public void ParseRoot <TEntity>(Expression <Func <TRootEntity, TEntity> > navigationExpression, string memberName)
{
var node = AddIfAbsent(Root, navigationExpression, memberName, typeof(TEntity), null, false);
CurrentNode = node;
}
