private static CodegenExpression CodegenMultikeyGetterBeanGet(
EventPropertyGetterSPI[] getters,
Type[] getterResultTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
var get = new CodegenExpressionLambda(method.Block)
.WithParams(CodegenNamedParam.From(typeof(EventBean), "bean"));
var lambda = NewInstance <ProxyEventPropertyValueGetter>(get);
var expressions = new CodegenExpression[getters.Length];
for (var i = 0; i < getters.Length; i++)
{
expressions[i] = getters[i].EventBeanGetCodegen(Ref("bean"), method, classScope);
var mkType = multiKeyClassRef.MKTypes[i];
var getterType = getterResultTypes[i];
expressions[i] = ExprNodeUtilityCodegen.CodegenCoerce(expressions[i], getterType, mkType, true);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
get.Block.BlockReturn(instance);
return(lambda);
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent
.MakeChild(typeof(FilterSpecParam), typeof(FilterSpecParamConstantForge), classScope);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar<FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName()));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var inner = NewInstance<ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
//var inner = NewAnonymousClass(
// method.Block,
// typeof(FilterSpecParam),
// Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator")));
//var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP);
//inner.AddMethod("GetFilterValue", getFilterValue);
getFilterValue.Block.BlockReturn(FilterValueSetParamImpl.CodegenNew(Constant(FilterConstant)));
method.Block.MethodReturn(inner);
return method;
}
public static CodegenExpression CodegenEvaluator(
ExprForge forge,
CodegenMethod method,
Type originator,
CodegenClassScope classScope)
{
var lambda = new CodegenExpressionLambda(method.Block)
.WithParams(LAMBDA_PARAMS);
if (forge.EvaluationType == null) {
lambda.Block.BlockReturn(ConstantNull());
return NewInstance<ProxyExprEvaluator>(lambda);
}
else if (forge.EvaluationType == typeof(void)) {
var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope);
lambda.Block
.LocalMethod(
evalMethod,
LAMBDA_REF_EPS,
LAMBDA_REF_ISNEWDATA,
LAMBDA_REF_EXPREVALCONTEXT)
.BlockReturn(ConstantNull());
}
else {
var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope, true);
lambda.Block.BlockReturn(
LocalMethod(
evalMethod,
LAMBDA_REF_EPS,
LAMBDA_REF_ISNEWDATA,
LAMBDA_REF_EXPREVALCONTEXT));
}
return NewInstance<ProxyExprEvaluator>(lambda);
}
public CodegenExpression MakeTimePeriodAnonymous(
CodegenMethod method,
CodegenClassScope classScope)
{
//var timeClass = NewAnonymousClass(method.Block, typeof(TimePeriodEval));
//var evalMethod = CodegenMethod.MakeMethod(typeof(TimePeriod), GetType(), classScope)
// .AddParam(PARAMS);
//timeClass.AddMethod("timePeriodEval", evalMethod);
var evalMethod = new CodegenExpressionLambda(method.Block).WithParams(PARAMS);
var timeClass = NewInstance<ProxyTimePeriodEval>(evalMethod);
var exprSymbol = new ExprForgeCodegenSymbol(true, true);
//var exprMethod = evalMethod.MakeChildWithScope(typeof(TimePeriod), GetType(), exprSymbol, classScope);
var exprMethod = method.MakeChild(typeof(TimePeriod), GetType(), classScope)
.AddParam(PARAMS);
CodegenExpression expression = forge.EvaluateGetTimePeriodCodegen(exprMethod, exprSymbol, classScope);
//exprSymbol.DerivedSymbolsCodegen(evalMethod, exprMethod.Block, classScope);
exprSymbol.DerivedSymbolsCodegen(exprMethod, exprMethod.Block, classScope);
exprMethod.Block.MethodReturn(expression);
evalMethod.Block.BlockReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT));
return timeClass;
}
private CodegenExpression MakeAggAssignables(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(AggregationResultFutureAssignable[]), GetType(), classScope);
method.Block
.DeclareVar<AggregationResultFutureAssignable[]>(
"assignables",
NewArrayByLength(typeof(AggregationResultFutureAssignable), Constant(_aggregationServices.Length)));
for (var i = 0; i < _aggregationServices.Length; i++) {
if (_aggregationServices[i] != null) {
var assign = new CodegenExpressionLambda(method.Block)
.WithParam<AggregationResultFuture>("future");
var anonymousClass = NewInstance<ProxyAggregationResultFutureAssignable>(assign);
//var anonymousClass = NewAnonymousClass(method.Block, typeof(AggregationResultFutureAssignable));
//var assign = CodegenMethod.MakeParentNode(typeof(void), GetType(), classScope)
// .AddParam(typeof(AggregationResultFuture), "future");
//anonymousClass.AddMethod("assign", assign);
var field = classScope.NamespaceScope.AddOrGetDefaultFieldWellKnown(
new CodegenFieldNameMatchRecognizeAgg(i),
typeof(AggregationResultFuture));
assign.Block.AssignRef(field, Ref("future"));
method.Block.AssignArrayElement(Ref("assignables"), Constant(i), anonymousClass);
}
}
method.Block.MethodReturn(Ref("assignables"));
return LocalMethod(method);
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent
.MakeChild(typeof(FilterSpecParam), GetType(), classScope);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar<FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName()));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var inner = NewInstance<ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
getFilterValue
.Block
.BlockReturn(FilterValueSetParamImpl.CodegenNew(ConstantNull()));
method.Block.MethodReturn(inner);
return method;
}
public CodegenExpression Make(
CodegenBlock codegenBlock,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var init = codegenClassScope.NamespaceScope.InitMethod;
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(_jsonEventType, EPStatementInitServicesConstants.REF));
var makeUndFunc = new CodegenExpressionLambda(codegenBlock)
.WithParam <object[]>("properties")
.WithBody(block => MakeUnderlyingCodegen(block, codegenMethodScope, codegenClassScope));
var manufacturer = NewInstance <ProxyJsonEventBeanManufacturer>(eventType, factory, makeUndFunc);
// CodegenExpressionNewAnonymousClass manufacturer = newAnonymousClass(init.getBlock(), EventBeanManufacturer.class);
//
// CodegenMethod makeUndMethod = CodegenMethod.makeParentNode(Object.class, this.getClass(), codegenClassScope).addParam(Object[].class, "properties");
// manufacturer.addMethod("makeUnderlying", makeUndMethod);
// makeUnderlyingCodegen(makeUndMethod, codegenClassScope);
//
// CodegenMethod makeMethod = CodegenMethod.makeParentNode(EventBean.class, this.getClass(), codegenClassScope).addParam(Object[].class, "properties");
// manufacturer.addMethod("make", makeMethod);
// makeMethod.getBlock()
// .declareVar(Object.class, "und", localMethod(makeUndMethod, ref("properties")))
// .methodReturn(exprDotMethod(factory, "adapterForTypedJson", ref("und"), beanType));
return(codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer));
}
public CodegenExpression Make(
CodegenBlock codegenBlock,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(_beanEventType, EPStatementInitServicesConstants.REF));
var makeUndLambda = new CodegenExpressionLambda(codegenBlock)
.WithParam<object[]>("properties")
.WithBody(block => MakeUnderlyingCodegen(codegenMethodScope, block, codegenClassScope));
var manufacturer = NewInstance<ProxyBeanEventBeanManufacturer>(
eventType, factory, makeUndLambda);
//var manufacturer = NewAnonymousClass(init.Block, typeof(EventBeanManufacturer));
//var makeUndMethod = CodegenMethod.MakeMethod(typeof(object), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("MakeUnderlying", makeUndMethod);
//MakeUnderlyingCodegen(makeUndMethod, codegenClassScope);
//var makeMethod = CodegenMethod.MakeMethod(typeof(EventBean), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("Make", makeMethod);
//makeMethod.Block
// .DeclareVar<object>("und", LocalMethod(makeUndMethod, Ref("properties")))
// .MethodReturn(ExprDotMethod(factory, "AdapterForTypedObject", Ref("und"), beanType));
return codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer);
}
public static void MakeSubstitutionSetter(
CodegenNamespaceScope packageScope,
CodegenBlock enclosingBlock,
CodegenClassScope classScope)
{
var assignLambda = new CodegenExpressionLambda(enclosingBlock)
.WithParam<StatementAIFactoryAssignments>("assignments");
//var assignMethod = CodegenMethod
// .MakeParentNode(typeof(void), typeof(StmtClassForgableStmtFields), classScope)
// .AddParam(typeof(StatementAIFactoryAssignments), "assignments");
//assignerSetterClass.AddMethod("Assign", assignMethod);
assignLambda.Block.ExprDotMethod(Ref("statementFields"), "Assign", Ref("assignments"));
//assignMethod.Block.StaticMethod(packageScope.FieldsClassName, "Assign", Ref("assignments"));
var setValueMethod = new CodegenExpressionLambda(enclosingBlock)
.WithParam(typeof(int), "index")
.WithParam(typeof(object), "value");
//assignerSetterClass.AddMethod("SetValue", setValueMethod);
var assignerSetterClass = NewInstance<ProxyFAFQueryMethodAssignerSetter>(
assignLambda, setValueMethod);
//var assignerSetterClass = NewAnonymousClass(enclosingBlock, typeof(FAFQueryMethodAssignerSetter));
enclosingBlock.ReturnMethodOrBlock(assignerSetterClass);
CodegenSubstitutionParamEntry.CodegenSetterBody(
classScope, setValueMethod.Block, Ref("statementFields"));
}
public static CodegenExpression CodegenEvaluatorWCoerce(
ExprForge forge,
Type optCoercionType,
CodegenMethod method,
Type generator,
CodegenClassScope classScope)
{
var evaluate = new CodegenExpressionLambda(method.Block)
.WithParams(PARAMS);
var evaluator = NewInstance<ProxyExprEvaluator>(evaluate);
//var evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator));
//var evaluate = CodegenMethod.MakeParentNode(typeof(object), generator, classScope)
// .AddParam(PARAMS);
//evaluator.AddMethod("Evaluate", evaluate);
var result = ConstantNull();
if (forge.EvaluationType != null) {
var evalMethod = CodegenLegoMethodExpression.CodegenExpression(forge, method, classScope, true);
result = LocalMethod(evalMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT);
var forgeEvaluationType = forge.EvaluationType.GetBoxedType();
if (optCoercionType != null && forgeEvaluationType != optCoercionType.GetBoxedType()) {
var coercer = SimpleNumberCoercerFactory.GetCoercer(
forgeEvaluationType,
optCoercionType.GetBoxedType());
evaluate.Block.DeclareVar(forgeEvaluationType, "result", result);
result = coercer.CoerceCodegen(Ref("result"), forge.EvaluationType);
}
}
evaluate.Block.BlockReturn(result);
return evaluator;
}
public CodegenExpression Make(
CodegenBlock codegenBlock,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var factory = codegenClassScope.AddOrGetDefaultFieldSharable(
EventBeanTypedEventFactoryCodegenField.INSTANCE);
var eventType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(this.eventType, EPStatementInitServicesConstants.REF));
var makeUndLambda = new CodegenExpressionLambda(codegenBlock)
.WithParam<object[]>("properties")
.WithBody(block => MakeUnderlyingCodegen(block, codegenClassScope));
var manufacturer = NewInstance<ProxyObjectArrayEventBeanManufacturer>(
eventType, factory, makeUndLambda);
//var makeUndProc = CodegenMethod.MakeMethod(typeof(object[]), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("MakeUnderlying", makeUndProc);
//MakeUnderlyingCodegen(makeUndProc, codegenClassScope);
//var makeProc = CodegenMethod.MakeMethod(typeof(EventBean), GetType(), codegenClassScope)
// .AddParam(typeof(object[]), "properties");
//manufacturer.AddMethod("Make", makeProc);
return codegenClassScope.AddDefaultFieldUnshared(true, typeof(EventBeanManufacturer), manufacturer);
}
public CodegenExpression Make(
CodegenMethod parent,
ModuleExpressionDeclaredInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ExpressionDeclItem), GetType(), classScope);
method.Block
.DeclareVar<byte[]>(
"bytes",
Constant(OptionalSodaBytes.Invoke()));
var supplierLambda = new CodegenExpressionLambda(method.Block);
supplierLambda.Block.BlockReturn(Ref("bytes"));
var supplierSodaBytes = NewInstance<Supplier<byte[]>>(supplierLambda);
method.Block
.DeclareVar<ExpressionDeclItem>(
"item",
NewInstance<ExpressionDeclItem>(
Constant(Name),
Constant(ParametersNames),
Constant(IsAlias)))
.SetProperty(Ref("item"), "OptionalSodaBytes", supplierSodaBytes)
.SetProperty(Ref("item"), "ModuleName", Constant(ModuleName))
.SetProperty(Ref("item"), "Visibility", Constant(Visibility))
.MethodReturn(Ref("item"));
return LocalMethod(method);
}
public static CodegenExpression CodegenEvaluatorObjectArray(
IList<ExprForge> forges,
CodegenMethod method,
Type generator,
CodegenClassScope classScope)
{
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
//var evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator));
//var evaluate = CodegenMethod.MakeParentNode<object>(generator, classScope)
// .AddParam(PARAMS);
//evaluator.AddMethod("Evaluate", evaluate);
var exprMethod = method
.MakeChildWithScope(
typeof(object),
typeof(CodegenLegoMethodExpression),
exprSymbol,
classScope)
.AddParam(PARAMS);
var expressions = new CodegenExpression[forges.Count];
for (var i = 0; i < forges.Count; i++) {
expressions[i] = forges[i]
.EvaluateCodegen(
forges[i].EvaluationType,
exprMethod,
exprSymbol,
classScope);
}
exprSymbol.DerivedSymbolsCodegen(exprMethod, exprMethod.Block, classScope);
exprMethod.Block.DeclareVar<object[]>(
"values",
NewArrayByLength(typeof(object), Constant(forges.Count)));
for (var i = 0; i < forges.Count; i++) {
var result = expressions[i];
exprMethod.Block.AssignArrayElement("values", Constant(i), result);
}
exprMethod.Block.MethodReturn(Ref("values"));
var evaluate = new CodegenExpressionLambda(method.Block)
.WithParams(PARAMS)
.WithBody(
block => block
.BlockReturn(
LocalMethod(
exprMethod,
REF_EPS,
REF_ISNEWDATA,
REF_EXPREVALCONTEXT)));
return NewInstance<ProxyExprEvaluator>(evaluate);
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent.MakeChild(typeof(FilterSpecParam), GetType(), classScope);
var get = ExprIdentNodeEvaluator.Getter.EventBeanGetCodegen(Ref("@event"), method, classScope);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var param = NewInstance<ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
//var param = NewAnonymousClass(
// method.Block,
// typeof(FilterSpecParam),
// Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator")));
//var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP);
//param.AddMethod("GetFilterValue", getFilterValue);
getFilterValue.Block
.DeclareVar<EventBean>(
"@event",
ExprDotMethod(Ref("matchedEvents"), "GetMatchingEventByTag", Constant(ResultEventAsName)))
.DeclareVar<object>("value", ConstantNull())
.IfRefNotNull("@event")
.AssignRef("value", get)
.BlockEnd();
if (IsMustCoerce) {
getFilterValue.Block.AssignRef(
"value",
_numberCoercer.CoerceCodegenMayNullBoxed(
Cast(typeof(object), Ref("value")),
typeof(object),
method,
classScope));
}
getFilterValue.Block.BlockReturn(FilterValueSetParamImpl.CodegenNew(Ref("value")));
method.Block.MethodReturn(param);
return method;
}
public virtual CodegenMethod MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(
typeof(ExprFilterSpecLookupable),
typeof(ExprFilterSpecLookupableForge),
classScope);
CodegenExpression singleEventEvalExpr = ConstantNull();
if (_optionalEventEvalForge != null) {
var eval = new CodegenExpressionLambda(method.Block)
.WithParam<EventBean>("bean")
.WithParam<ExprEvaluatorContext>("ctx");
var anonymous = NewInstance<ProxyExprEventEvaluator>(eval);
eval.Block.BlockReturn(
_optionalEventEvalForge.EventBeanWithCtxGet(Ref("bean"), Ref("ctx"), method, classScope));
singleEventEvalExpr = anonymous;
}
CodegenExpression epsEvalExpr = ConstantNull();
if (_optionalExprForge != null) {
epsEvalExpr = ExprNodeUtilityCodegen.CodegenEvaluator(
_optionalExprForge, method, typeof(ExprFilterSpecLookupableForge), classScope);
}
CodegenExpression serdeExpr = _valueSerde == null ? ConstantNull() : _valueSerde.Codegen(method, classScope, null);
CodegenExpression returnTypeExpr = _returnType == null ? ConstantNull() : Typeof(_returnType);
method.Block
.DeclareVar<ExprEventEvaluator>("eval", singleEventEvalExpr)
.DeclareVar<ExprEvaluator>("expr", epsEvalExpr)
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
NewInstance<ExprFilterSpecLookupable>(
Constant(_expression),
Ref("eval"),
Ref("expr"),
returnTypeExpr,
Constant(_isNonPropertyGetter),
serdeExpr))
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY)
.Add(
"RegisterLookupable",
symbols.GetAddEventType(method),
Ref("lookupable")))
.MethodReturn(Ref("lookupable"));
return method;
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent.MakeChild(typeof(FilterSpecParam), GetType(), classScope);
var lookupableExpr = LocalMethod(lookupable.MakeCodegen(method, symbols, classScope));
method.Block
.DeclareVar<ExprFilterSpecLookupable>("lookupable", lookupableExpr)
.DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator));
//var param = NewAnonymousClass(
// method.Block,
// typeof(FilterSpecParam),
// Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator")));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var param = NewInstance<ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
//var getFilterValue = CodegenMethod
// .MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP);
//param.AddMethod("GetFilterValue", getFilterValue);
getFilterValue.Block
.DeclareVar<EventBean>("props", ExprDotName(REF_EXPREVALCONTEXT, "ContextProperties"))
.IfNullReturnNull(Ref("props"))
.DeclareVar<object>("result", _getter.EventBeanGetCodegen(Ref("props"), method, classScope));
if (_numberCoercer != null) {
getFilterValue.Block.AssignRef(
"result",
_numberCoercer.CoerceCodegenMayNullBoxed(
Cast(typeof(object), Ref("result")),
typeof(object),
method,
classScope));
}
var returnExpr = FilterValueSetParamImpl.CodegenNew(Ref("result"));
getFilterValue.Block.BlockReturn(returnExpr);
method.Block.MethodReturn(param);
return method;
}
public static CodegenExpression CodegenMultiKeyFromArrayTransform(
MultiKeyClassRef optionalMultiKeyClasses,
CodegenMethod method,
CodegenClassScope classScope)
{
var fromLambda = new CodegenExpressionLambda(method.Block).WithParam <object[]>("keys");
var fromClass = NewInstance <ProxyMultiKeyFromObjectArray>(fromLambda);
// CodegenExpressionNewAnonymousClass fromClass = NewAnonymousClass(method.Block, typeof(MultiKeyFromObjectArray));
// CodegenMethod from = CodegenMethod
// .MakeParentNode(typeof(object), typeof(MultiKeyCodegen), classScope)
// .AddParam(typeof(object[]), "keys");
// fromClass.AddMethod("from", from);
if (optionalMultiKeyClasses == null || optionalMultiKeyClasses.ClassNameMK == null)
{
fromLambda.Block.BlockReturn(ArrayAtIndex(Ref("keys"), Constant(0)));
}
else if (optionalMultiKeyClasses.MKTypes.Length == 1)
{
var paramType = optionalMultiKeyClasses.MKTypes[0];
if (paramType == null || !paramType.IsArray)
{
fromLambda.Block.BlockReturn(ArrayAtIndex(Ref("keys"), Constant(0)));
}
else
{
var mktype = MultiKeyPlanner.GetMKClassForComponentType(paramType.GetElementType());
fromLambda.Block.BlockReturn(NewInstance(mktype, FlexCast(paramType, ArrayAtIndex(Ref("keys"), Constant(0)))));
}
}
else
{
var expressions = new CodegenExpression[optionalMultiKeyClasses.MKTypes.Length];
for (var i = 0; i < expressions.Length; i++)
{
expressions[i] = FlexCast(optionalMultiKeyClasses.MKTypes[i], ArrayAtIndex(Ref("keys"), Constant(i)));
}
var instance = optionalMultiKeyClasses.ClassNameMK.Type != null
? NewInstance(optionalMultiKeyClasses.ClassNameMK.Type, expressions)
: NewInstanceInner(optionalMultiKeyClasses.ClassNameMK.Name, expressions);
fromLambda.Block.BlockReturn(instance);
}
return(fromClass);
}
public CodegenExpression CodegenSerialize(
JsonSerializerForgeRefs refs,
CodegenMethod method,
CodegenClassScope classScope)
{
// We need to encode the _subForge into a lambda of its own
var itemSerializer = new CodegenExpressionLambda(method.Block)
.WithBody(block => _subForge.CodegenSerialize(refs, method, classScope));
return(StaticMethod(
typeof(JsonSerializerUtil),
"WriteJsonList",
refs.Context,
refs.Field,
itemSerializer));
}
public CodegenExpression InitCtorScoped()
{
var parse = new CodegenExpressionLambda(classScope.NamespaceScope.InitMethod.Block)
.WithParam<string>("text");
var anonymousClass = NewInstance<ProxySimpleTypeParser>(parse);
//CodegenExpressionNewAnonymousClass) anonymousClass = NewAnonymousClass(
// classScope.NamespaceScope.InitMethod.Block,
// typeof(SimpleTypeParser));
//CodegenMethod parse = CodegenMethod.MakeParentNode(typeof(object), this.GetType(), classScope)
// .AddParam(typeof(string), "text");
//anonymousClass.AddMethod("Parse", parse);
parse.Block.BlockReturn(parser.Codegen(Ref("text")));
return anonymousClass;
}
public virtual CodegenMethod MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(
typeof(ExprFilterSpecLookupable),
typeof(ExprFilterSpecLookupableForge),
classScope);
CodegenExpression getterExpr;
if (optionalEventPropForge != null) {
var get = new CodegenExpressionLambda(method.Block)
.WithParams(CodegenNamedParam.From(typeof(EventBean), "bean"));
var anonymous = NewInstance<ProxyEventPropertyValueGetter>(get);
//var anonymous = NewAnonymousClass(method.Block, typeof(EventPropertyValueGetter));
//var get = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(CodegenNamedParam.From(typeof(EventBean), "bean"));
//anonymous.AddMethod("Get", get);
get.Block.BlockReturn(optionalEventPropForge.EventBeanGetCodegen(Ref("bean"), method, classScope));
getterExpr = anonymous;
}
else {
getterExpr = ConstantNull();
}
method.Block.DeclareVar<EventPropertyValueGetter>("getter", getterExpr);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
NewInstance<ExprFilterSpecLookupable>(
Constant(expression),
Ref("getter"),
Typeof(returnType),
Constant(isNonPropertyGetter)))
.Expression(
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.FILTERSHAREDLOOKUPABLEREGISTERY)
.Add(
"RegisterLookupable",
symbols.GetAddEventType(method),
Ref("lookupable")))
.MethodReturn(Ref("lookupable"));
return method;
}
public CodegenExpression MakeWCopy(
CodegenMethodScope scope,
CodegenClassScope classScope)
{
var copyMethodField = classScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanCopyMethod),
_copyMethod.MakeCopyMethodClassScoped(classScope));
var method = scope.MakeChild(typeof(EventBeanUpdateHelperWCopy), GetType(), classScope);
var updateInternal = MakeUpdateInternal(method, classScope);
var updateWCopy = new CodegenExpressionLambda(method.Block)
.WithParam(typeof(EventBean), "matchingEvent")
.WithParam(typeof(EventBean[]), NAME_EPS)
.WithParam(typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT);
var clazz = NewInstance<EventBeanUpdateHelperWCopy>(updateWCopy);
//var clazz = NewAnonymousClass(method.Block, typeof(EventBeanUpdateHelperWCopy));
//var updateWCopy = CodegenMethod.MakeParentNode(typeof(EventBean), GetType(), classScope)
// .AddParam(typeof(EventBean), "matchingEvent")
// .AddParam(typeof(EventBean[]), NAME_EPS)
// .AddParam(typeof(ExprEvaluatorContext), NAME_EXPREVALCONTEXT);
//clazz.AddMethod("updateWCopy", updateWCopy);
updateWCopy.Block
.Apply(
Instblock(
classScope,
"qInfraUpdate",
Ref("matchingEvent"),
REF_EPS,
Constant(UpdateItems.Length),
ConstantTrue()))
.DeclareVar<EventBean>("copy", ExprDotMethod(copyMethodField, "Copy", Ref("matchingEvent")))
.AssignArrayElement(REF_EPS, Constant(0), Ref("copy"))
.AssignArrayElement(REF_EPS, Constant(2), Ref("matchingEvent"))
.LocalMethod(updateInternal, REF_EPS, REF_EXPREVALCONTEXT, Ref("copy"))
.Apply(Instblock(classScope, "aInfraUpdate", Ref("copy")))
.ReturnMethodOrBlock(Ref("copy"));
method.Block.MethodReturn(clazz);
return LocalMethod(method);
}
public static CodegenExpression CodegenWidener(
TypeWidenerSPI widener,
CodegenMethod method,
Type originator,
CodegenClassScope classScope)
{
var widen = new CodegenExpressionLambda(method.Block).WithParam<object>("input");
var anonymousClass = NewInstance<ProxyTypeWidener>(widen);
//var anonymousClass = NewAnonymousClass(method.Block, typeof(TypeWidener));
//var widen = CodegenMethod.MakeParentNode(typeof(object), originator, classScope)
// .AddParam(typeof(object), "input");
//anonymousClass.AddMethod("widen", widen);
var widenResult = widener.WidenCodegen(Ref("input"), method, classScope);
widen.Block.BlockReturn(widenResult);
return anonymousClass;
}
public static CodegenExpression MakeAnonymous(
FilterSpecParamFilterForEvalDoubleForge eval,
Type originator,
CodegenClassScope classScope,
CodegenMethod method)
{
var getFilterValueDouble = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP)
.WithBody(
block => block.BlockReturn(
CodegenExpressionBuilder.Cast(
typeof(double),
eval.MakeCodegen(classScope, method))));
//anonymousClass.AddMethod("GetFilterValueDouble", getFilterValueDouble);
//getFilterValueDouble.Block.MethodReturn(
// CodegenExpressionBuilder.Cast(
// typeof(double),
// eval.MakeCodegen(
// classScope,
// getFilterValueDouble)));
//var getFilterValue = new CodegenExpressionLambda(method.Block)
// .WithParams(FilterSpecParam.GET_FILTER_VALUE_FP)
// .WithBody(
// block => block.BlockReturn(
// CodegenExpressionBuilder.ExprDotMethod(
// CodegenExpressionBuilder.Ref("this"),
// "GetFilterValueDouble",
// FilterSpecParam.REF_MATCHEDEVENTMAP,
// ExprForgeCodegenNames.REF_EXPREVALCONTEXT,
// FilterSpecParam.REF_STMTCTXFILTEREVALENV)));
//anonymousClass.AddMethod("GetFilterValue", getFilterValue);
//getFilterValue.Block.MethodReturn(
// CodegenExpressionBuilder.ExprDotMethod(
// CodegenExpressionBuilder.Ref("this"),
// "GetFilterValueDouble",
// FilterSpecParam.REF_MATCHEDEVENTMAP,
// ExprForgeCodegenNames.REF_EXPREVALCONTEXT,
// FilterSpecParam.REF_STMTCTXFILTEREVALENV));
return(CodegenExpressionBuilder.NewInstance <ProxyFilterSpecParamFilterForEvalDouble>(getFilterValueDouble));
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent.MakeChild(typeof(FilterSpecParam), typeof(FilterSpecParamConstantForge), classScope);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var param = NewInstance<ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
//var param = NewAnonymousClass(
// method.Block,
// typeof(FilterSpecParam),
// Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator")));
//var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP);
//param.AddMethod("GetFilterValue", getFilterValue);
var returnType = typeof(DoubleRange);
var castType = typeof(double?);
if (lookupable.ReturnType == typeof(string)) {
castType = typeof(string);
returnType = typeof(StringRange);
}
getFilterValue.Block
.DeclareVar<object>("min", _min.MakeCodegen(classScope, method))
.DeclareVar<object>("max", _max.MakeCodegen(classScope, method))
.DeclareVar<object>("value", NewInstance(returnType, Cast(castType, Ref("min")), Cast(castType, Ref("max"))))
.BlockReturn(FilterValueSetParamImpl.CodegenNew(Ref("value")));
method.Block.MethodReturn(param);
return method;
}
public static CodegenExpression CodegenSimpleParser(
SimpleTypeParserSPI parser,
CodegenMethod method,
Type originator,
CodegenClassScope classScope)
{
var parse = new CodegenExpressionLambda(method.Block)
.WithParam <string>("value");
var typeParser = NewInstance <ProxySimpleTypeParser>(parse);
//var anonymousClass =
// NewAnonymousClass(method.Block, typeof(SimpleTypeParser));
//var parse = CodegenMethod
// .MakeParentNode<object>(originator, classScope)
// .AddParam<string>("value");
//anonymousClass.AddMethod("Parse", parse);
parse.Block.BlockReturn(parser.Codegen(Ref("value")));
return(typeParser);
}
private static CodegenExpression CodegenMultiKeyExprEvaluator(
ExprForge[] expressionNodes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
var evaluate = new CodegenExpressionLambda(method.Block)
.WithParams(PARAMS);
var evaluator = NewInstance <ProxyExprEvaluator>(evaluate);
// CodegenExpressionNewAnonymousClass evaluator = NewAnonymousClass(method.Block, typeof(ExprEvaluator));
// CodegenMethod evaluate = CodegenMethod
// .MakeParentNode(typeof(object), typeof(StmtClassForgeableMultiKey), classScope)
// .AddParam(ExprForgeCodegenNames.PARAMS);
//
// evaluator.AddMethod("evaluate", evaluate);
var exprSymbol = new ExprForgeCodegenSymbol(true, null);
var exprMethod = method
.MakeChildWithScope(typeof(object), typeof(CodegenLegoMethodExpression), exprSymbol, classScope)
.AddParam(ExprForgeCodegenNames.PARAMS);
var expressions = new CodegenExpression[expressionNodes.Length];
for (var i = 0; i < expressionNodes.Length; i++)
{
expressions[i] = CodegenExpressionMayCoerce(expressionNodes[i], multiKeyClassRef.MKTypes[i], exprMethod, exprSymbol, classScope);
}
var instance = multiKeyClassRef.ClassNameMK.Type != null
? NewInstance(multiKeyClassRef.ClassNameMK.Type, expressions)
: NewInstanceInner(multiKeyClassRef.ClassNameMK.Name, expressions);
exprSymbol.DerivedSymbolsCodegen(method, exprMethod.Block, classScope);
exprMethod.Block.MethodReturn(instance);
evaluate.Block.BlockReturn(LocalMethod(exprMethod, REF_EPS, REF_ISNEWDATA, REF_EXPREVALCONTEXT));
return(evaluator);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(ContainedEventEvalGetter), this.GetType(), classScope);
var getFragment = new CodegenExpressionLambda(method.Block)
.WithParams(new CodegenNamedParam(typeof(EventBean), "@event"));
var anonymousClass = NewInstance<ProxyEventPropertyFragmentGetter>(getFragment);
//var anonymousClass = NewAnonymousClass(
// method.Block,
// typeof(EventPropertyFragmentGetter));
//var getFragment = CodegenMethod.MakeParentNode(typeof(object), this.GetType(), classScope)
// .AddParam(typeof(EventBean), "@event");
//anonymousClass.AddMethod("GetFragment", getFragment);
getFragment.Block.BlockReturn(getter.EventBeanFragmentCodegen(Ref("@event"), method /* getFragment */, classScope));
method.Block.MethodReturn(NewInstance<ContainedEventEvalGetter>(anonymousClass));
return LocalMethod(method);
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent
.MakeChild(typeof(FilterSpecParam), GetType(), classScope);
method.Block
.DeclareVar <ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar <FilterOperator>("filterOperator", EnumValue(typeof(FilterOperator), filterOperator.GetName()));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var inner = NewInstance <ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
var rhsExpression = CodegenLegoMethodExpression.CodegenExpression(_value.Forge, method, classScope);
var matchEventConvertor = _convertor.Make(method, classScope);
CodegenExpression valueExpr = LocalMethod(rhsExpression, Ref("eps"), ConstantTrue(), REF_EXPREVALCONTEXT);
if (_numberCoercer != null)
{
valueExpr = _numberCoercer.CoerceCodegenMayNullBoxed(valueExpr, _value.Forge.EvaluationType, method, classScope);
}
getFilterValue.Block
.DeclareVar <EventBean[]>("eps", LocalMethod(matchEventConvertor, FilterSpecParam.REF_MATCHEDEVENTMAP))
.BlockReturn(FilterValueSetParamImpl.CodegenNew(valueExpr));
method.Block.MethodReturn(inner);
return(method);
}
public override CodegenMethod MakeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbolWEventType symbols)
{
var method = parent.MakeChild(typeof(FilterSpecParam), GetType(), classScope);
method.Block
.DeclareVar<ExprFilterSpecLookupable>(
"lookupable",
LocalMethod(lookupable.MakeCodegen(method, symbols, classScope)))
.DeclareVar<FilterOperator>("filterOperator", EnumValue(filterOperator));
var getFilterValue = new CodegenExpressionLambda(method.Block)
.WithParams(FilterSpecParam.GET_FILTER_VALUE_FP);
var param = NewInstance<ProxyFilterSpecParam>(
Ref("lookupable"),
Ref("filterOperator"),
getFilterValue);
//var param = NewAnonymousClass(
// method.Block,
// typeof(FilterSpecParam),
// Arrays.AsList<CodegenExpression>(Ref("lookupable"), Ref("filterOperator")));
//var getFilterValue = CodegenMethod.MakeParentNode(typeof(object), GetType(), classScope)
// .AddParam(FilterSpecParam.GET_FILTER_VALUE_FP);
//param.AddMethod("GetFilterValue", getFilterValue);
var value = _deployTimeConstant.CodegenGetDeployTimeConstValue(classScope);
if (_numberCoercer != null) {
value = _numberCoercer.CoerceCodegenMayNullBoxed(value, _returnType, method, classScope);
}
getFilterValue.Block.BlockReturn(FilterValueSetParamImpl.CodegenNew(value));
method.Block.MethodReturn(param);
return method;
}
public CodegenExpression CodegenSerialize(
JsonSerializerForgeRefs refs,
CodegenMethod method,
CodegenClassScope classScope)
{
var subRefs = new JsonSerializerForgeRefs(
Ref("_context"),
Ref("_arrayItem"),
Ref("_name"));
var serializationExpr = _subForge.CodegenSerialize(subRefs, method, classScope);
var itemSerializer = new CodegenExpressionLambda(method.Block)
.WithParam(typeof(JsonSerializationContext), "_context")
.WithParam(_componentType, "_arrayItem")
.WithBody(block => block.Expression(serializationExpr));
return(StaticMethod(
typeof(JsonSerializerUtil),
"WriteNestedArray",
refs.Context,
refs.Field,
itemSerializer));
}
