public static CodegenExpression Codegen(
EnumAverageScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(double?),
typeof(EnumAverageEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar<double>("sum", Constant(0d))
.DeclareVar<int>("count", Constant(0))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(
NewArrayByLength(typeof(object), Constant(1)),
resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerType,
"num",
forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope));
if (innerType.CanBeNull()) {
forEach.IfRefNull("num").BlockContinue();
}
forEach.Increment("count")
.AssignRef(
"sum",
Op(
Ref("sum"),
"+",
SimpleNumberCoercerFactory.CoercerDouble.CodegenDouble(Ref("num"), innerType)))
.BlockEnd();
block.IfCondition(EqualsIdentity(Ref("count"), Constant(0)))
.BlockReturn(ConstantNull())
.MethodReturn(Op(Ref("sum"), "/", Ref("count")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumMostLeastFrequentScalarLamdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var returnType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var methodNode = codegenMethodScope
.MakeChildWithScope(
returnType,
typeof(EnumMostLeastFrequentScalarLamdaForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(ConstantNull())
.DeclareVar<IDictionary<object, int>>("items", NewInstance(typeof(HashMap<object, int>)))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar<object>(
"item",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar<int?>("existing", ExprDotMethod(Ref("items"), "GetBoxed", Ref("item")))
.IfCondition(EqualsNull(Ref("existing")))
.AssignRef("existing", Constant(1))
.IfElse()
.Increment("existing")
.BlockEnd()
.ExprDotMethod(Ref("items"), "Put", Ref("item"), Unbox(Ref("existing")));
block.MethodReturn(
Cast(
returnType,
StaticMethod(
typeof(EnumMostLeastFrequentEventForgeEval),
"GetEnumMostLeastFrequentResult",
Ref("items"),
Constant(forge.isMostFrequent))));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(_resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(typeof(IDictionary <object, object>), typeof(EnumToMapScalar), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var hasIndex = _numParameters >= 2;
var hasSize = _numParameters >= 3;
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumValue(typeof(EmptyDictionary <object, object>), "Instance"));
block.DeclareVar <IDictionary <object, object> >("map", NewInstance(typeof(NullableDictionary <object, object>)))
.DeclareVar(
typeof(ObjectArrayEventBean),
"resultEvent",
NewInstance(typeof(ObjectArrayEventBean), NewArrayByLength(typeof(object), Constant(_numParameters)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("resultEvent"))
.DeclareVar <object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
if (hasIndex)
{
block.DeclareVar <int>("count", Constant(-1));
}
if (hasSize)
{
block.AssignArrayElement(Ref("props"), Constant(2), ExprDotName(REF_ENUMCOLL, "Count"));
}
var forEach = block
.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"));
if (hasIndex)
{
forEach.IncrementRef("count").AssignArrayElement("props", Constant(1), Ref("count"));
}
forEach
.DeclareVar <object>("key", InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar <object>("value", _secondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.Expression(ExprDotMethod(Ref("map"), "Put", Ref("key"), Ref("value")));
block.MethodReturn(Ref("map"));
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return EnumAverageDecimalScalarLambdaForgeEval.Codegen(
this,
premade,
codegenMethodScope,
codegenClassScope);
}
public static CodegenExpression Codegen(
EnumMinMaxScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var innerType = forge.InnerExpression.EvaluationType;
var innerTypeBoxed = Boxing.GetBoxedType(innerType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(innerTypeBoxed, typeof(EnumMinMaxScalarLambdaForgeEval), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar(innerTypeBoxed, "minKey", ConstantNull())
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerTypeBoxed,
"value",
forge.InnerExpression.EvaluateCodegen(innerTypeBoxed, methodNode, scope, codegenClassScope));
if (innerType.CanBeNull()) {
forEach.IfRefNull("value").BlockContinue();
}
forEach.IfCondition(EqualsNull(Ref("minKey")))
.AssignRef("minKey", Ref("value"))
.IfElse()
.IfCondition(
Relational(
ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")),
forge.max ? LT : GT,
Constant(0)))
.AssignRef("minKey", Ref("value"));
block.MethodReturn(Ref("minKey"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumTakeWhileEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var returnType = typeof(FlexCollection);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
returnType,
typeof(EnumTakeWhileEventsForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var innerValue = forge.InnerExpression.EvaluateCodegen(
typeof(bool?),
methodNode,
scope,
codegenClassScope);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
var blockSingle = block
.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar<EventBean>("item",
ExprDotMethod(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "EventBeanCollection"), "First"))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("item"));
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
forge.InnerExpression.EvaluationType,
innerValue,
FlexEmpty());
blockSingle.BlockReturn(FlexEvent(Ref("item")));
block.DeclareVar<ArrayDeque<EventBean>>("result", NewInstance(typeof(ArrayDeque<EventBean>)));
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenBreakIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
innerValue);
forEach.Expression(ExprDotMethod(Ref("result"), "Add", Ref("next")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumAverageDecimalScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
CodegenExpression math =
codegenClassScope.AddOrGetDefaultFieldSharable(new MathContextCodegenField(forge.optionalMathContext));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(decimal?),
typeof(EnumAverageDecimalScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
block.DeclareVar<EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal>(
"agg",
NewInstance(typeof(EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal), math))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(
NewArrayByLength(typeof(object), Constant(1)),
resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerType,
"num",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope));
if (innerType.CanBeNull()) {
forEach.IfRefNull("num").BlockContinue();
}
forEach.Expression(ExprDotMethod(Ref("agg"), "Enter", Ref("num")));
block.MethodReturn(ExprDotName(Ref("agg"), "Value"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var indexTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(typeof(ObjectArrayEventType), EventTypeUtility.ResolveTypeCodegen(FieldEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(ReturnType(), GetType(), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
var returnEmpty = ReturnIfEmptyOptional();
if (returnEmpty != null)
{
block.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(returnEmpty);
}
block.DeclareVar(
typeof(ObjectArrayEventBean),
"indexEvent",
NewInstance(typeof(ObjectArrayEventBean), NewArrayByLength(typeof(object), Constant(numParameters - 1)), indexTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda + 1), Ref("indexEvent"))
.DeclareVar <object[]>("props", ExprDotName(Ref("indexEvent"), "Properties"));
block.DeclareVar <int>("count", Constant(-1));
if (numParameters == 3)
{
block.AssignArrayElement(Ref("props"), Constant(1), ExprDotName(REF_ENUMCOLL, "Count"));
}
InitBlock(block, methodNode, scope, codegenClassScope);
if (HasForEachLoop())
{
var forEach = block.ForEach(typeof(EventBean), "next", REF_ENUMCOLL)
.IncrementRef("count")
.AssignArrayElement("props", Constant(0), Ref("count"))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("next"));
ForEachBlock(forEach, methodNode, scope, codegenClassScope);
}
ReturnResult(block);
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public static CodegenExpression Codegen(
EnumGroupByKeyValueSelectorScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var paramTypes = EnumForgeCodegenNames.PARAMS;
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(IDictionary<object, object>),
typeof(EnumGroupByKeyValueSelectorScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(object), typeof(object) }))
.DeclareVar<IDictionary<object, object>>("result", NewInstance(typeof(LinkedHashMap<object, object>)))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar<object>(
"key",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar<object>(
"entry",
forge.secondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar<ICollection<object>>(
"value",
Cast(typeof(ICollection<object>), ExprDotMethod(Ref("result"), "Get", Ref("key"))))
.IfRefNull("value")
.AssignRef("value", NewInstance(typeof(List<object>)))
.Expression(ExprDotMethod(Ref("result"), "Put", Ref("key"), Ref("value")))
.BlockEnd()
.Expression(ExprDotMethod(Ref("value"), "Add", Ref("entry")));
block.MethodReturn(Ref("result"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumOrderByAscDescEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerBoxedType = forge.InnerExpression.EvaluationType.GetBoxedType();
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(ICollection<EventBean>),
typeof(EnumOrderByAscDescEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar<OrderedDictionary<object, object>>(
"sort",
NewInstance(typeof(OrderedDictionary<object, object>)))
.DeclareVar<bool>("hasColl", ConstantFalse());
block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar(
innerBoxedType,
"value",
forge.InnerExpression.EvaluateCodegen(innerBoxedType, methodNode, scope, codegenClassScope))
.DeclareVar<object>("entry", ExprDotMethod(Ref("sort"), "Get", Ref("value")))
.IfCondition(EqualsNull(Ref("entry")))
.Expression(ExprDotMethod(Ref("sort"), "Put", Ref("value"), Ref("next")))
.BlockContinue()
.IfCondition(InstanceOf(Ref("entry"), typeof(ICollection<object>)))
.ExprDotMethod(Cast(typeof(ICollection<object>), Ref("entry")), "Add", Ref("next"))
.BlockContinue()
.DeclareVar<Deque<object>>("coll", NewInstance<ArrayDeque<object>>(Constant(2)))
.ExprDotMethod(Ref("coll"), "Add", Ref("entry"))
.ExprDotMethod(Ref("coll"), "Add", Ref("next"))
.ExprDotMethod(Ref("sort"), "Put", Ref("value"), Ref("coll"))
.AssignRef("hasColl", ConstantTrue())
.BlockEnd();
block.MethodReturn(
Unwrap<EventBean>(
StaticMethod(
typeof(EnumOrderByAscDescEventsForgeEval),
"EnumOrderBySortEval",
Ref("sort"),
Ref("hasColl"),
Constant(forge.descending))));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumWhereIndexEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var indexTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.indexEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumWhereIndexEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
block
.DeclareVar<ArrayDeque<EventBean>>("result", NewInstance(typeof(ArrayDeque<EventBean>)))
.DeclareVar<ObjectArrayEventBean>("indexEvent", NewInstance<ObjectArrayEventBean>(
NewArrayByLength(typeof(object), Constant(1)), indexTypeMember))
.AssignArrayElement(
EnumForgeCodegenNames.REF_EPS,
Constant(forge.streamNumLambda + 1),
Ref("indexEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("indexEvent"), "Properties"))
.DeclareVar<int>("count", Constant(-1));
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.Increment("count")
.AssignArrayElement("props", Constant(0), Ref("count"))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.streamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.innerExpression.EvaluationType,
forge.innerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.Expression(ExprDotMethod(Ref("result"), "Add", Ref("next")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var type = _resultType.GetCodegenReturnType();
var method = codegenMethodScope
.MakeChild(type, typeof(EnumFirstOf), codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS)
.Block
.IfCondition(Or(EqualsNull(EnumForgeCodegenNames.REF_ENUMCOLL), ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty")))
.BlockReturn(ConstantNull())
.MethodReturn(FlexCast(type, ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First")));
return(LocalMethod(method, args.Expressions));
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var method = codegenMethodScope
.MakeChild(typeof(FlexCollection), typeof(EnumDistinctScalarForge), codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS)
.Block
.IfCondition(Relational(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), LE, Constant(1)))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL)
.IfCondition(InstanceOf(Ref("enumcoll"), typeof(ISet<object>)))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL)
.MethodReturn(FlexWrap(NewInstance<LinkedHashSet<object>>(EnumForgeCodegenNames.REF_ENUMCOLL)));
return LocalMethod(method, args.Expressions);
}
public static CodegenExpression Codegen(
EnumMostLeastFrequentEventForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var returnType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
returnType,
typeof(EnumMostLeastFrequentEventForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(ConstantNull())
.DeclareVar<IDictionary<object, int>>(
"items",
NewInstance(typeof(HashMap<object, int>)));
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar<object>( // type erasure issue
"item",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar<int?>(
"existing",
ExprDotMethod(Ref("items"), "GetBoxed", Ref("item")))
.IfCondition(EqualsNull(Ref("existing")))
.AssignRef("existing", Constant(1))
.IfElse()
.Increment("existing")
.BlockEnd()
.ExprDotMethod(Ref("items"), "Put", Ref("item"), Unbox(Ref("existing")));
block.MethodReturn(
Cast(
returnType,
StaticMethod(
typeof(EnumMostLeastFrequentEventForgeEval),
"GetEnumMostLeastFrequentResult",
Ref("items"),
Constant(forge.isMostFrequent))));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var type = _resultType.GetCodegenReturnType().GetBoxedType();
var method = codegenMethodScope.MakeChild(type, typeof(EnumLastOf), codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS)
.Block
.DeclareVar <object>("result", ConstantNull())
.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignRef("result", Ref("next"))
.BlockEnd()
.MethodReturn(FlexCast(type, Ref("result")));
return(LocalMethod(method, args.Expressions));
}
public static CodegenExpression Codegen(
EnumSumScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
forge.sumMethodFactory.ValueType.GetBoxedType(),
typeof(EnumSumEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
forge.sumMethodFactory.CodegenDeclare(block);
block.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerType,
"value",
forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope));
if (innerType.CanBeNull()) {
forEach.IfRefNull("value").BlockContinue();
}
forge.sumMethodFactory.CodegenEnterNumberTypedNonNull(forEach, Ref("value"));
forge.sumMethodFactory.CodegenReturn(block);
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumAllOfScalarForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var typeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.type, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(typeof(bool), typeof(EnumAllOfScalarForgeEval), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
//block.CommentFullLine("-- trace --");
//block.Debug("enumcoll: {0}", ExprDotMethod(Ref("enumcoll"), "RenderAny"));
block.IfConditionReturnConst(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"), true);
block.DeclareVar<ObjectArrayEventBean>(
"evalEvent",
NewInstance<ObjectArrayEventBean>(
NewArrayByLength(typeof(object), Constant(1)),
typeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("evalEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("evalEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenReturnBoolIfNullOrBool(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope),
false,
null,
false,
false);
block.MethodReturn(ConstantTrue());
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumDistinctScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var innerType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumDistinctScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(Relational(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), LE, Constant(1)))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL)
.DeclareVar<IDictionary<object, object>>("distinct", NewInstance(typeof(LinkedHashMap<object, object>)))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerType,
"comparable",
forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope))
.IfCondition(Not(ExprDotMethod(Ref("distinct"), "CheckedContainsKey", Ref("comparable"))))
.Expression(ExprDotMethod(Ref("distinct"), "Put", Ref("comparable"), Ref("next")))
.BlockEnd();
block.MethodReturn(FlexWrap(ExprDotName(Ref("distinct"), "Values")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var returnType = typeof(FlexCollection);
var namedParams = EnumForgeCodegenNames.PARAMS;
var collectionType = IsScalar
? typeof(List<object>)
: typeof(List<EventBean>);
var method = codegenMethodScope
.MakeChild(returnType, typeof(EnumReverseForge), codegenClassScope)
.AddParam(namedParams);
var block = method.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
if (IsScalar) {
var listType = typeof(List<object>);
block.DeclareVar(
listType,
"result",
NewInstance(
listType,
ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "ObjectCollection")));
}
else {
var listType = typeof(List<EventBean>);
block.DeclareVar(
listType,
"result",
NewInstance(
listType,
ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "EventBeanCollection")));
}
block
.ExprDotMethod(Ref("result"), "Reverse")
.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(method, args.Expressions);
}
public static CodegenExpression Codegen(
EnumUnionForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var namedParams = EnumForgeCodegenNames.PARAMS;
var returnType = typeof(FlexCollection);
var listType = forge.scalar
? typeof(List<object>)
: typeof(List<EventBean>);
var subProperty = forge.scalar
? "ObjectCollection"
: "EventBeanCollection";
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(returnType, typeof(EnumUnionForgeEval), scope, codegenClassScope)
.AddParam(namedParams);
var block = methodNode.Block;
if (forge.scalar) {
block.DeclareVar<FlexCollection>(
"other",
forge.evaluatorForge.EvaluateGetROCollectionScalarCodegen(methodNode, scope, codegenClassScope));
}
else {
block.DeclareVar<FlexCollection>(
"other",
forge.evaluatorForge.EvaluateGetROCollectionEventsCodegen(methodNode, scope, codegenClassScope));
}
block.IfCondition(Or(EqualsNull(Ref("other")), ExprDotMethod(Ref("other"), "IsEmpty")))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
block
.DebugStack()
.DeclareVar(listType, "result", NewInstance(listType))
.Expression(ExprDotMethod(Ref("result"), "AddAll",
ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, subProperty)))
.Expression(ExprDotMethod(Ref("result"), "AddAll",
ExprDotName(Ref("other"), subProperty)))
.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumMinMaxEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var innerTypeBoxed = Boxing.GetBoxedType(innerType);
//var paramTypes = (innerType == typeof(EventBean))
// ? EnumForgeCodegenNames.PARAMS_EVENTBEAN
// : EnumForgeCodegenNames.PARAMS_OBJECT;
var paramTypes = EnumForgeCodegenNames.PARAMS;
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(innerTypeBoxed, typeof(EnumMinMaxEventsForgeEval), scope, codegenClassScope)
.AddParam(paramTypes);
var block = methodNode.Block
.DeclareVar(innerTypeBoxed, "minKey", ConstantNull());
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar(
innerTypeBoxed,
"value",
forge.InnerExpression.EvaluateCodegen(innerTypeBoxed, methodNode, scope, codegenClassScope));
if (innerType.CanBeNull()) {
forEach.IfRefNull("value").BlockContinue();
}
forEach.IfCondition(EqualsNull(Ref("minKey")))
.AssignRef("minKey", Ref("value"))
.IfElse()
.IfCondition(
Relational(
ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")),
forge.max ? LT : GT,
Constant(0)))
.AssignRef("minKey", Ref("value"));
block.MethodReturn(Ref("minKey"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var type = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(_resultType));
var paramTypes = EnumForgeCodegenNames.PARAMS;
var method = codegenMethodScope
.MakeChild(type, typeof(EnumLastOfNoPredicateForge), codegenClassScope)
.AddParam(paramTypes)
.Block
.DeclareVar<object>("result", ConstantNull())
.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignRef("result", Ref("next"))
.BlockEnd()
.MethodReturn(Cast(type, Ref("result")));
return LocalMethod(method, args.Expressions);
}
public static CodegenExpression Codegen(
EnumSelectFromScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumSelectFromScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL)
.DeclareVar<ArrayDeque<object>>(
"result",
NewInstance<ArrayDeque<object>>(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count")))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar<object>(
"item",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.IfCondition(NotEqualsNull(Ref("item")))
.Expression(ExprDotMethod(Ref("result"), "Add", Ref("item")));
block.MethodReturn(FlexWrap(Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumLastOfPredicateScalarForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var typeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.type, EPStatementInitServicesConstants.REF)));
var resultType = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(forge.resultType));
var paramsType = EnumForgeCodegenNames.PARAMS;
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(resultType, typeof(EnumLastOfPredicateScalarForgeEval), scope, codegenClassScope)
.AddParam(paramsType);
CodegenBlock block;
block = methodNode.Block
.DeclareVar<object>("result", ConstantNull())
.DeclareVar<ObjectArrayEventBean>(
"evalEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), typeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("evalEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("evalEvent"), "Properties"));
var forEach = block
.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.AssignRef("result", Ref("next"));
block.MethodReturn(Cast(resultType, Ref("result")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumIntersectForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var namedParams = EnumForgeCodegenNames.PARAMS;
var returnType = typeof(FlexCollection);
var methodNode = codegenMethodScope
.MakeChildWithScope(
returnType,
typeof(EnumIntersectForgeEval),
scope,
codegenClassScope)
.AddParam(namedParams);
var block = methodNode.Block;
if (forge.scalar) {
block.DeclareVar<FlexCollection>(
"other",
forge.evaluatorForge.EvaluateGetROCollectionScalarCodegen(methodNode, scope, codegenClassScope));
}
else {
block.DeclareVar<FlexCollection>(
"other",
forge.evaluatorForge.EvaluateGetROCollectionEventsCodegen(methodNode, scope, codegenClassScope));
}
block.MethodReturn(
FlexWrap(
StaticMethod(
typeof(EnumIntersectForgeEval),
"EnumIntersectForgeEvalSet",
Ref("other"),
EnumForgeCodegenNames.REF_ENUMCOLL)));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
CodegenExpression math =
codegenClassScope.AddOrGetDefaultFieldSharable(new MathContextCodegenField(_optionalMathContext));
var method = codegenMethodScope
.MakeChild(typeof(decimal?), typeof(EnumAverageScalarForge), codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS)
.Block
.DeclareVar<EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal>(
"agg",
NewInstance(typeof(EnumAverageDecimalEventsForgeEval.AggregatorAvgDecimal), math))
.ForEach(typeof(object), "num", EnumForgeCodegenNames.REF_ENUMCOLL)
.IfRefNull("num")
.BlockContinue()
.Expression(ExprDotMethod(Ref("agg"), "Enter", Ref("num")))
.BlockEnd()
.MethodReturn(ExprDotName(Ref("agg"), "Value"));
return LocalMethod(method, args.Expressions);
}
public CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
Type arrayType = TypeHelper.GetArrayType(_arrayComponentType);
ExprForgeCodegenSymbol scope = new ExprForgeCodegenSymbol(false, null);
CodegenMethod methodNode = codegenMethodScope.MakeChildWithScope(arrayType, typeof(EnumArrayOfScalarNoParams), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
CodegenBlock block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(NewArrayByLength(_arrayComponentType, Constant(0)))
.DeclareVar(arrayType, "result", NewArrayByLength(_arrayComponentType, ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count")))
.DeclareVar <int>("count", Constant(0));
block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(Ref("result"), Ref("count"), Cast(_arrayComponentType, Ref("next")))
.IncrementRef("count");
block.MethodReturn(Ref("result"));
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(typeof(EventBean), typeof(EnumFirstOfEvent), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
InnerExpression.EvaluationType,
InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.BlockReturn(Ref("next"));
block.MethodReturn(ConstantNull());
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var method = codegenMethodScope
.MakeChild(typeof(double?), typeof(EnumAverageScalarForge), codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS)
.Block
.DeclareVar<double>("sum", Constant(0d))
.DeclareVar<int>("count", Constant(0))
.ForEach(typeof(object), "num", EnumForgeCodegenNames.REF_ENUMCOLL)
.IfRefNull("num")
.BlockContinue()
.Increment("count")
.AssignRef("sum", Op(Ref("sum"), "+", ExprDotMethod(Ref("num"), "AsDouble")))
.BlockEnd()
.IfCondition(EqualsIdentity(Ref("count"), Constant(0)))
.BlockReturn(ConstantNull())
.MethodReturn(Op(Ref("sum"), "/", Ref("count")));
return LocalMethod(method, args.Expressions);
}
public static CodegenExpression Codegen(
EnumAverageDecimalEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
CodegenExpression math =
codegenClassScope.AddOrGetDefaultFieldSharable(new MathContextCodegenField(forge.optionalMathContext));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(decimal?),
typeof(EnumAverageDecimalEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
block.DeclareVar<AggregatorAvgDecimal>(
"agg",
NewInstance<AggregatorAvgDecimal>(math));
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar(
innerType,
"num",
forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope));
if (innerType.CanBeNull()) {
forEach.IfRefNull("num").BlockContinue();
}
forEach.Expression(ExprDotMethod(Ref("agg"), "Enter", Ref("num")))
.BlockEnd();
block.MethodReturn(ExprDotName(Ref("agg"), "Value"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
