public static CodegenExpression Codegen(
EnumSumEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
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);
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar(
innerType.GetBoxedType(),
"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(
EnumDistinctEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumDistinctEventsForgeEval),
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, EventBean>>("distinct", NewInstance(typeof(LinkedHashMap<object, EventBean>)));
block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), 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 static CodegenExpression Codegen(
EnumCountOfSelectorScalarForge 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(int), typeof(EnumCountOfSelectorScalarForgeEval), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar<int>("count", Constant(0))
.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(Ref("props"), Constant(0), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.Increment("count");
block.MethodReturn(Ref("count"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public CodegenMethod EvaluateRowCodegen(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var symbols = new ExprForgeCodegenSymbol(true, true);
var method = parent.MakeChildWithScope(
typeof(IDictionary<string, object>),
typeof(CodegenLegoMethodExpression),
symbols,
classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var selectClause = SelectClause;
var selectAsNames = SelectAsNames;
var expressions = new CodegenExpression[selectClause.Length];
for (var i = 0; i < selectClause.Length; i++) {
expressions[i] = selectClause[i].Forge.EvaluateCodegen(typeof(object), method, symbols, classScope);
}
symbols.DerivedSymbolsCodegen(method, method.Block, classScope);
method.Block.DeclareVar<IDictionary<string, object>>(
"map",
NewInstance(typeof(HashMap<string, object>)));
for (var i = 0; i < selectClause.Length; i++) {
method.Block.ExprDotMethod(Ref("map"), "Put", Constant(selectAsNames[i]), expressions[i]);
}
method.Block.MethodReturn(Ref("map"));
return method;
}
private CodegenMethod EvaluateGetROCollectionScalarCodegenRewritten(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var nodeObject = GetNodeObject(codegenClassScope);
var scope = new ExprForgeCodegenSymbol(true, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(ICollection<object>),
typeof(ExprDeclaredForgeBase),
scope,
codegenClassScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
CodegenExpression refEPS = scope.GetAddEPS(methodNode);
CodegenExpression refExprEvalCtx = scope.GetAddExprEvalCtx(methodNode);
// generate code for the inner value so we know its symbols and derived symbols
var innerValue =
((ExprEnumerationForge) InnerForge).EvaluateGetROCollectionScalarCodegen(
methodNode,
scope,
codegenClassScope);
// produce derived symbols
var block = methodNode.Block;
scope.DerivedSymbolsCodegen(methodNode, block, codegenClassScope);
if (isCache) {
block
.DeclareVar<ExpressionResultCacheForDeclaredExprLastColl>(
"cache",
ExprDotMethodChain(refExprEvalCtx)
.Get("ExpressionResultCacheService")
.Get("AllocateDeclaredExprLastColl"))
.DeclareVar<ExpressionResultCacheEntryEventBeanArrayAndCollBean>(
"entry",
ExprDotMethod(
Ref("cache"),
"GetDeclaredExpressionLastColl",
nodeObject,
refEPS))
.IfCondition(NotEqualsNull(Ref("entry")))
.BlockReturn(
Unwrap<object>(ExprDotName(Ref("entry"), "Result")))
.DeclareVar<ICollection<object>>("result", innerValue)
.Expression(
ExprDotMethod(
Ref("cache"),
"SaveDeclaredExpressionLastColl",
nodeObject,
refEPS,
FlexWrap(Unwrap<EventBean>(Ref("result")))));
}
else {
block.DeclareVar<ICollection<object>>("result", innerValue);
}
block.MethodReturn(FlexWrap(Ref("result")));
return methodNode;
}
public static CodegenExpression Codegen(
EnumAllOfEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(bool),
typeof(EnumAllOfEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
block.IfConditionReturnConst(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"), true);
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenReturnBoolIfNullOrBool(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope),
true,
false,
false,
false);
block.MethodReturn(ConstantTrue());
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenMethod CodegenMapSelect(
IList<ExprNode> selectClause,
string[] selectAsNames,
Type generator,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var method = parent.MakeChildWithScope(
typeof(IDictionary<string, object>),
generator,
exprSymbol,
classScope)
.AddParam(PARAMS);
method.Block.DeclareVar<IDictionary<string, object>>(
"map",
NewInstance(typeof(HashMap<string, object>), Constant(selectAsNames.Length + 2)));
var expressions = new CodegenExpression[selectAsNames.Length];
for (var i = 0; i < selectClause.Count; i++) {
expressions[i] = selectClause[i].Forge.EvaluateCodegen(typeof(object), method, exprSymbol, classScope);
}
exprSymbol.DerivedSymbolsCodegen(method, method.Block, classScope);
for (var i = 0; i < selectClause.Count; i++) {
method.Block.ExprDotMethod(Ref("map"), "Put", Constant(selectAsNames[i]), expressions[i]);
}
method.Block.MethodReturn(Ref("map"));
return method;
}
public static CodegenExpression Codegen(
EnumTakeForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var returnType = typeof(FlexCollection);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumTakeForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var sizeType = forge.SizeEval.EvaluationType;
var block = methodNode.Block
.DebugStack()
.DeclareVar(
sizeType,
"size",
forge.SizeEval.EvaluateCodegen(sizeType, methodNode, scope, codegenClassScope));
if (sizeType.CanBeNull()) {
block.IfRefNullReturnNull("size");
}
block.MethodReturn(
StaticMethod(
typeof(EnumTakeForgeEval),
"EvaluateEnumTakeMethod",
EnumForgeCodegenNames.REF_ENUMCOLL,
SimpleNumberCoercerFactory.CoercerInt.CodegenInt(Ref("size"), sizeType)));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumSequenceEqualForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var namedParams = EnumForgeCodegenNames.PARAMS;
var methodNode = codegenMethodScope
.MakeChildWithScope(typeof(bool), typeof(EnumSequenceEqualForgeEval), scope, codegenClassScope)
.AddParam(namedParams);
methodNode.Block.MethodReturn(
StaticMethod(
typeof(EnumSequenceEqualForgeEval),
"EnumSequenceEqualsCompare",
EnumForgeCodegenNames.REF_ENUMCOLL,
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope)));
return LocalMethod(
methodNode,
args.Eps,
args.Enumcoll,
args.IsNewData,
args.ExprCtx);
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams premade,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
ExprForgeCodegenSymbol scope = new ExprForgeCodegenSymbol(false, null);
CodegenMethod methodNode = codegenMethodScope
.MakeChildWithScope(ReturnType(), this.GetType(), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
CodegenExpression returnIfEmpty = ReturnIfEmptyOptional();
if (returnIfEmpty != null)
{
methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(returnIfEmpty);
}
InitBlock(methodNode.Block, methodNode, scope, codegenClassScope);
CodegenBlock forEach = methodNode.Block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(StreamNumLambda), Ref("next"));
ForEachBlock(forEach, methodNode, scope, codegenClassScope);
ReturnResult(methodNode.Block);
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
public CodegenMethod CodegenWithEventType(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var symbolsWithType = new SAIFFInitializeSymbolWEventType();
var method = parent.MakeChildWithScope(typeof(FilterSpecPlan), typeof(FilterSpecParamForge), symbolsWithType, classScope)
.AddParam(typeof(EventType), SAIFFInitializeSymbolWEventType.REF_EVENTTYPE.Ref)
.AddParam(typeof(EPStatementInitServices), SAIFFInitializeSymbol.REF_STMTINITSVC.Ref);
if (Paths.Length == 0) {
method.Block.MethodReturn(PublicConstValue(typeof(FilterSpecPlan), "EMPTY_PLAN"));
return method;
}
method.Block.DeclareVar<FilterSpecPlanPath[]>("paths", NewArrayByLength(typeof(FilterSpecPlanPath), Constant(Paths.Length)));
for (var i = 0; i < Paths.Length; i++) {
method.Block.AssignArrayElement("paths", Constant(i), LocalMethod(Paths[i].Codegen(method, symbolsWithType, classScope)));
}
method.Block
.DeclareVar<FilterSpecPlan>("plan", NewInstance(typeof(FilterSpecPlan)))
.SetProperty(Ref("plan"), "Paths", Ref("paths"))
.SetProperty(Ref("plan"), "FilterConfirm", OptionalEvaluator(FilterConfirm, method, classScope))
.SetProperty(Ref("plan"), "FilterNegate", OptionalEvaluator(FilterNegate, method, classScope))
.SetProperty(Ref("plan"), "Convertor", ConvertorForge == null ? ConstantNull() : ConvertorForge.MakeAnonymous(method, classScope))
.ExprDotMethod(Ref("plan"), "Initialize")
.MethodReturn(Ref("plan"));
return method;
}
public static CodegenExpression Codegen(
EnumToMapEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(IDictionary<string, object>),
typeof(EnumToMapEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(string), typeof(object) }));
block.DeclareVar<IDictionary<string, object>>("map", NewInstance(typeof(HashMap<string, object>)));
block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar<string>(
"key",
forge.InnerExpression.EvaluateCodegen(typeof(string), methodNode, scope, codegenClassScope))
.DeclareVar<object>(
"value",
forge.secondExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.Expression(ExprDotMethod(Ref("map"), "Put", Ref("key"), Ref("value")));
block.MethodReturn(Ref("map"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumFirstOfPredicateEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(EventBean),
typeof(EnumFirstOfPredicateEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block;
var forEach = block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"));
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
forEach,
forge.InnerExpression.EvaluationType,
forge.InnerExpression.EvaluateCodegen(typeof(bool?), methodNode, scope, codegenClassScope));
forEach.BlockReturn(Ref("next"));
block.MethodReturn(ConstantNull());
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
public static CodegenExpression Codegen(
EnumSelectFromEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(ICollection<object>),
typeof(EnumSelectFromEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(FlexEmpty())
.DeclareVar<ArrayDeque<object>>(
"result",
NewInstance<ArrayDeque<object>>(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count")));
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), 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(
EnumTakeWhileScalarForge 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(FlexCollection),
typeof(EnumTakeWhileScalarForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var innerValue = forge.InnerExpression.EvaluateCodegen(
typeof(bool?),
methodNode,
scope,
codegenClassScope);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL);
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 blockSingle = block
.IfCondition(EqualsIdentity(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), Constant(1)))
.DeclareVar<object>(
"item",
ExprDotMethodChain(EnumForgeCodegenNames.REF_ENUMCOLL).Add("First"))
.AssignArrayElement("props", Constant(0), Ref("item"));
CodegenLegoBooleanExpression.CodegenReturnValueIfNotNullAndNotPass(
blockSingle,
forge.InnerExpression.EvaluationType,
innerValue,
FlexEmpty());
blockSingle.BlockReturn(FlexValue(Ref("item")));
block.DeclareVar<ArrayDeque<object>>("result", NewInstance(typeof(ArrayDeque<object>)));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), 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(
EnumWhereEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumWhereEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(EnumValue(typeof(FlexCollection), "Empty"));
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.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 static CodegenMethod CodegenMethod(
ExprNode[] expressionNodes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var eventUnpackMethod = parent
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), CodegenSymbolProviderEmpty.INSTANCE, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var exprMethod = eventUnpackMethod
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var expressions = new CodegenExpression[expressionNodes.Length];
for (var i = 0; i < expressionNodes.Length; i++)
{
var forge = expressionNodes[i].Forge;
expressions[i] = CodegenExpressionMayCoerce(forge, multiKeyClassRef.MKTypes[i], exprMethod, exprSymbol, classScope);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
exprSymbol.DerivedSymbolsCodegen(eventUnpackMethod, exprMethod.Block, classScope);
exprMethod.Block.MethodReturn(instance);
eventUnpackMethod.Block.MethodReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT));
return(eventUnpackMethod);
}
private CodegenMethod EvaluateCodegenRewritten(
Type requiredType,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var nodeObject = GetNodeObject(codegenClassScope);
var evaluationType = DetermineEvaluationType(requiredType);
var scope = new ExprForgeCodegenSymbol(true, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(evaluationType, typeof(ExprDeclaredForgeBase), scope, codegenClassScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
CodegenExpression refEPS = scope.GetAddEPS(methodNode);
CodegenExpression refExprEvalCtx = scope.GetAddExprEvalCtx(methodNode);
// generate code for the inner value so we know its symbols and derived symbols
var innerValue = InnerForge.EvaluateCodegen(
requiredType,
methodNode,
scope,
codegenClassScope);
// produce derived symbols
var block = methodNode.Block;
scope.DerivedSymbolsCodegen(methodNode, block, codegenClassScope);
if (isCache) {
CodegenExpression eval = ExprDotName(Ref("entry"), "Result");
if (evaluationType != typeof(object)) {
eval = Cast(InnerForge.EvaluationType, eval);
}
block
.DeclareVar<ExpressionResultCacheForDeclaredExprLastValue>(
"cache",
ExprDotMethodChain(refExprEvalCtx)
.Get("ExpressionResultCacheService")
.Get("AllocateDeclaredExprLastValue"))
.DeclareVar<ExpressionResultCacheEntryEventBeanArrayAndObj>(
"entry",
ExprDotMethod(Ref("cache"), "GetDeclaredExpressionLastValue", nodeObject, refEPS))
.IfCondition(NotEqualsNull(Ref("entry")))
.BlockReturn(eval)
.DeclareVar(evaluationType, "result", innerValue)
.Expression(
ExprDotMethod(
Ref("cache"),
"SaveDeclaredExpressionLastValue",
nodeObject,
refEPS,
Ref("result")));
}
else {
block.DeclareVar(evaluationType, "result", innerValue);
}
block.MethodReturn(Ref("result"));
return methodNode;
}
public static CodegenExpression Codegen(
EnumMinMaxByScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var innerTypeBoxed = Boxing.GetBoxedType(innerType);
var resultTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(forge.resultType));
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(
resultTypeBoxed,
typeof(EnumMinMaxByScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar(innerTypeBoxed, "minKey", ConstantNull())
.DeclareVar(resultTypeBoxed, "result", 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))
.IfRefNull("value")
.BlockContinue();
forEach.IfCondition(EqualsNull(Ref("minKey")))
.AssignRef("minKey", Ref("value"))
.AssignRef("result", Cast(resultTypeBoxed, Ref("next")))
.IfElse()
.IfCondition(
Relational(
ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")),
forge.max ? LT : GT,
Constant(0)))
.AssignRef("minKey", Ref("value"))
.AssignRef("result", Cast(resultTypeBoxed, Ref("next")));
block.MethodReturn(Ref("result"));
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>), GetType(), scope, codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var hasIndex = _numParameters >= 2;
var hasSize = _numParameters >= 3;
var returnIfEmpty = ReturnIfEmptyOptional();
if (returnIfEmpty != null)
{
methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(returnIfEmpty);
}
InitBlock(methodNode.Block, methodNode, scope, codegenClassScope);
methodNode.Block
.DeclareVar <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)
{
methodNode.Block.DeclareVar <int>("count", Constant(-1));
}
if (hasSize)
{
methodNode.Block.AssignArrayElement(Ref("props"), Constant(2), ExprDotName(REF_ENUMCOLL, "Count"));
}
var forEach = methodNode.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"));
}
ForEachBlock(forEach, methodNode, scope, codegenClassScope);
ReturnResult(methodNode.Block);
return(LocalMethod(methodNode, premade.Eps, premade.Enumcoll, premade.IsNewData, premade.ExprCtx));
}
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(
EnumAggregateEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var typeMember = 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.Initialization.EvaluationType,
typeof(EnumAggregateEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var initType = forge.Initialization.EvaluationType;
var initTypeBoxed = initType.GetBoxedType();
var unboxRequired = initType != initTypeBoxed;
var innerType = forge.InnerExpression.EvaluationType;
var block = methodNode.Block;
block.DeclareVar(
initTypeBoxed,
"value",
forge.Initialization.EvaluateCodegen(initType, methodNode, scope, codegenClassScope))
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(
unboxRequired
? (CodegenExpression) ExprDotName(Ref("value"), "Value")
: (CodegenExpression) Ref("value"));
block.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), typeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("value"))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda + 1), Ref("next"))
.AssignRef(
"value",
forge.InnerExpression.EvaluateCodegen(
innerType, methodNode, scope, codegenClassScope))
.BlockEnd();
block.MethodReturn(
unboxRequired
? (CodegenExpression) ExprDotName(Ref("value"), "Value")
: (CodegenExpression) Ref("value"));
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);
}
protected override CodegenMethod CodegenConstructorInit(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var saiffInitializeSymbol = new SAIFFInitializeSymbol();
var method = parent.MakeChildWithScope(TypeOfFactory(), GetType(), saiffInitializeSymbol, classScope)
.AddParam(typeof(EPStatementInitServices), REF_STMTINITSVC.Ref);
method.Block.MethodReturn(LocalMethod(forge.InitializeCodegen(method, saiffInitializeSymbol, classScope)));
return method;
}
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));
}
protected override CodegenMethod CodegenConstructorInit(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var saiffInitializeSymbol = new SAIFFInitializeSymbol();
var method = parent.MakeChildWithScope(TypeOfFactory(), GetType(), saiffInitializeSymbol, classScope)
.AddParam(typeof(EPStatementInitServices), REF_STMTINITSVC.Ref);
method.Block
.ExprDotMethod(REF_STMTINITSVC, "ActivateVariable", Constant(_variableName), _serde.Codegen(method, classScope, null))
.MethodReturn(LocalMethod(_forge.InitializeCodegen(method, saiffInitializeSymbol, classScope)));
return method;
}
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 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 CodegenGet(
CodegenExpression beanExpression,
ExprDotNodeForgeStaticMethod forge,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
forge.EvaluationType,
typeof(ExprDotNodeForgeStaticMethodEval),
exprSymbol,
codegenClassScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var args = AllArgumentExpressions(
forge.ChildForges,
forge.StaticMethod,
methodNode,
exprSymbol,
codegenClassScope);
exprSymbol.DerivedSymbolsCodegen(methodNode, methodNode.Block, codegenClassScope);
AppendArgExpressions(args, methodNode.Block);
// try block
var tryBlock = methodNode.Block.TryCatch();
var invoke = CodegenInvokeExpression(
forge.TargetObject,
forge.StaticMethod,
args,
codegenClassScope);
tryBlock.BlockReturn(invoke);
// exception handling
AppendCatch(
tryBlock,
forge.StaticMethod,
forge.OptionalStatementName,
forge.ClassOrPropertyName,
forge.IsRethrowExceptions,
args);
// end method
methodNode.Block.MethodReturn(ConstantNull());
return LocalMethod(
methodNode,
NewArrayWithInit(typeof(EventBean), beanExpression),
ConstantTrue(),
ConstantNull());
}
