private static ProcessingResult SetMemberInstances(MemberInfo member, ProcessingResult instanceResult, ProcessingResult valueResult)
{
if (instanceResult.IsSingleItem)
{
return(new ProcessingResult(true, SetValue(instanceResult.Result, member, valueResult.Result), true));
}
var resultList = new List <object>();
if (valueResult.IsSingleItem)
{
resultList.AddRange(from object instance in instanceResult.GetItems()
select SetValue(instance, member, valueResult.Result));
return(new ProcessingResult(true, resultList));
}
var valueEnumerator = valueResult.GetItems().GetEnumerator();
valueEnumerator.MoveNext();
foreach (var instance in instanceResult.GetItems())
{
resultList.Add(SetValue(instance, member, valueEnumerator.Current));
valueEnumerator.MoveNext();
}
return(new ProcessingResult(true, resultList));
}
private static ProcessingResult ProcessAssignmentBinding(EvaluatedMemberBinding binding, ProcessingResult instanceResult)
{
if (instanceResult.IsSingleItem)
{
return(new ProcessingResult(true, SetValue(instanceResult.Result, binding.Member, binding.Result.Result), true));
}
var resultList = new List <object>();
if (binding.Result.IsSingleItem)
{
resultList.AddRange(from object instance in instanceResult.GetItems()
select SetValue(instance, binding.Member, binding.Result.Result));
return(new ProcessingResult(true, resultList));
}
var valueEnumerator = binding.Result.GetItems().GetEnumerator();
valueEnumerator.MoveNext();
foreach (var instance in instanceResult.GetItems())
{
resultList.Add(SetValue(instance, binding.Member, valueEnumerator.Current));
valueEnumerator.MoveNext();
}
return(new ProcessingResult(true, resultList));
}
protected ProcessingResult GetKeys(LambdaExpression keySelector, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
var keys = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(keySelector.ReturnType));
var compiledSelector = CompiledExpressionStorage.GetOrAddCompiledLambda(keySelector);
foreach (var item in parentResult.GetItems())
{
keys.Add(compiledSelector.DynamicInvoke(item));
}
return(new ProcessingResult(true, keys));
}
var nodeReferences = parentResult.GetDeferredList();
var keysResult = ExpressionProcessingHelper.ProcessExpression(keySelector.Body, nodeReferences, context);
if (!keysResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
if (keysResult.IsSingleItem)
{
keysResult = ExpressionProcessingHelper.CopyInstances(keysResult, nodeReferences.Count,
() => ExpressionProcessingHelper.ProcessExpression(keySelector.Body, nodeReferences, context).Result);
}
keysResult = new ProcessingResult(true, keysResult.GetLoadedItems(keySelector.ReturnType));
return(QueryProcessingHelper.NormalizeMultipleResult(keysResult, keySelector.ReturnType));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
var items = parentResult.GetItems();
var enumerator = items.GetEnumerator();
var count = (int)((ConstantExpression)query.Arguments[1]).Value;
var currentIndex = 0;
while ((currentIndex < count) && enumerator.MoveNext())
{
currentIndex++;
}
var itemType = parentResult.IsDeferred()
? typeof(NodeReference)
: QueryProcessingHelper.GetSourceParameterType(query);
var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(itemType));
while (enumerator.MoveNext())
{
resultList.Add(enumerator.Current);
}
return(new ProcessingResult(true, resultList));
}
private static ProcessingResult GetMemberInstances(MemberInfo member, ProcessingResult instanceResult)
{
if (instanceResult.IsSingleItem)
{
return(new ProcessingResult(true, GetValue(instanceResult.Result, member), true));
}
var instances = from object item in instanceResult.GetItems()
select GetValue(item, member);
return(new ProcessingResult(true, instances.ToList()));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
var index = (int)((ConstantExpression)query.Arguments[1]).Value;
var enumerator = parentResult.GetItems().GetEnumerator();
while (index >= 0)
{
if (!enumerator.MoveNext())
{
//ReSharper disable once NotResolvedInText
throw new ArgumentOutOfRangeException("index", "Index was out of range. Must be non-negative and less than the size of the collection.");
}
index--;
}
return(new ProcessingResult(true, enumerator.Current, true));
}
internal static ProcessingResult NormalizeMultipleResult(ProcessingResult result, Type targetItemType)
{
if (result.IsDeferred())
{
return(result);
}
var sourceItems = result.GetItems();
var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(targetItemType));
foreach (var sourceItem in sourceItems)
{
resultList.Add(sourceItem);
}
return(new ProcessingResult(true, resultList));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var predicateExpression = query.Arguments[1];
var items = parentResult.GetItems();
var enumerator = items.GetEnumerator();
var resultList = new List <NodeReference>();
while (enumerator.MoveNext())
{
var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicateExpression,
new List <NodeReference>(1)
{
(NodeReference)enumerator.Current
}, context);
if (!predicateResult.IsSuccess)
{
return(ProcessingResult.Unsuccessful);
}
var predicateValue = ((IList <NodeReference>)predicateResult.Result).Any();
if (predicateValue)
{
ConditionTrueCallback(resultList, enumerator.Current);
continue;
}
ConditionFalseCallback(resultList, enumerator.Current);
break;
}
while (enumerator.MoveNext())
{
ConditionFalseCallback(resultList, enumerator.Current);
}
return(new ProcessingResult(true, resultList));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
var index = (int)((ConstantExpression)query.Arguments[1]).Value;
var enumerator = parentResult.GetItems().GetEnumerator();
var elementType = QueryProcessingHelper.GetReturnParameterType(query);
while (index >= 0)
{
if (!enumerator.MoveNext())
{
return(new ProcessingResult(true, InstanceCreator.GetDefaultValue(elementType), true));
}
index--;
}
return(new ProcessingResult(true, enumerator.Current, true));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
var hasPredicate = query.Arguments.Count == 2;
if (!hasPredicate)
{
return(ProcessQuery(parentResult.GetItems().GetEnumerator(), QueryProcessingHelper.GetReturnParameterType(query)));
}
if (!parentResult.IsDeferred())
{
return(ProcessingResult.Unsuccessful);
}
var predicate = query.Arguments[1];
var predicateResult = ExpressionProcessingHelper.ProcessPredicate(predicate, parentResult.GetDeferredItems(), context);
return(predicateResult.IsSuccess
? ProcessQuery(predicateResult.GetItems().GetEnumerator(), QueryProcessingHelper.GetReturnParameterType(query))
: ProcessingResult.Unsuccessful);
}
internal static ProcessingResult ProcessListInitializer(EvaluatedListInitializer initializer, ProcessingResult instanceResult)
{
var argumentEnumerators = initializer.Arguments
.Select(a => new
{
IsSingle = a.IsSingleItem,
Value = a.Result,
Enumerator = a.IsSingleItem ? null : a.GetItems().GetEnumerator()
})
.ToList();
Func <bool> moveNext = () => argumentEnumerators.Where(a => !a.IsSingle).All(a => a.Enumerator.MoveNext());
Func <object[]> getNextArguments = () => argumentEnumerators
.Select(a => a.IsSingle ? a.Value : a.Enumerator.Current)
.ToArray();
Func <object, object> processInitializer = instance =>
{
initializer.AddMethod.Invoke(instance, getNextArguments());
return(instance);
};
if (instanceResult.IsSingleItem)
{
return(new ProcessingResult(true, processInitializer(instanceResult.Result), true));
}
var resultList = new List <object>();
foreach (var instance in instanceResult.GetItems())
{
if (!moveNext())
{
throw new InvalidOperationException("Unable to perform iteration");
}
resultList.Add(processInitializer(instance));
}
return(new ProcessingResult(true, resultList));
}
public ProcessingResult ProcessQuery(MethodCallExpression query, ProcessingResult parentResult, DataContext context)
{
var items = parentResult.GetItems();
var enumerator = items.GetEnumerator();
if (enumerator.MoveNext())
{
return(new ProcessingResult(true, parentResult.Result));
}
var elementType = QueryProcessingHelper.GetSourceParameterType(query);
var hasDefaultValue = query.Arguments.Count > 1;
var defaultValue = hasDefaultValue
? ((ConstantExpression)query.Arguments[1]).Value
: InstanceCreator.GetDefaultValue(elementType);
var resultList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(elementType));
resultList.Add(defaultValue);
return(new ProcessingResult(true, resultList));
}