public override CodegenExpression EvaluateCodegenUninstrumented(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
typeof(string),
typeof(ExprTypeofNodeForgeFragmentType),
codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar<EventBean>("@event", ArrayAtIndex(refEPS, Constant(streamId)))
.IfRefNullReturnNull("@event")
.DeclareVar<object>(
"fragment",
getter.EventBeanFragmentCodegen(Ref("@event"), methodNode, codegenClassScope))
.IfRefNullReturnNull("fragment")
.IfInstanceOf("fragment", typeof(EventBean))
.BlockReturn(
ExprDotMethodChain(Cast(typeof(EventBean), Ref("fragment"))).Get("EventType").Get("Name"))
.IfCondition(ExprDotMethodChain(Ref("fragment")).Add("GetType").Get("IsArray"))
.BlockReturn(Constant(fragmentType + "[]"))
.MethodReturn(ConstantNull());
return LocalMethod(methodNode);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
typeof(long?),
typeof(ExprEvaluatorStreamDTPropFragment),
codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar<EventBean>("theEvent", ArrayAtIndex(refEPS, Constant(streamId)))
.IfRefNullReturnNull("theEvent")
.DeclareVar<object>(
"@event",
getterFragment.EventBeanFragmentCodegen(Ref("theEvent"), methodNode, codegenClassScope))
.IfCondition(Not(InstanceOf(Ref("@event"), typeof(EventBean))))
.BlockReturn(ConstantNull())
.MethodReturn(
CodegenLegoCast.CastSafeFromObjectType(
typeof(long),
getterTimestamp.EventBeanGetCodegen(
Cast(typeof(EventBean), Ref("@event")),
methodNode,
codegenClassScope)));
return LocalMethod(methodNode);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope parent,
ExprForgeCodegenSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(EventBean), typeof(PropertyDotNonLambdaFragmentIndexedForge), classScope);
CodegenExpressionRef refEps = symbols.GetAddEPS(method);
method.Block
.DeclareVar <EventBean>("@event", ArrayAtIndex(refEps, Constant(_streamId)))
.IfRefNullReturnNull("@event")
.DeclareVar <EventBean[]>("array", Cast(typeof(EventBean[]), _getter.EventBeanFragmentCodegen(Ref("@event"), method, classScope)))
.DeclareVar(typeof(int?), "index", _indexExpr.Forge.EvaluateCodegen(typeof(int?), method, symbols, classScope))
.IfRefNullReturnNull("index")
.IfCondition(Relational(Ref("index"), CodegenExpressionRelational.CodegenRelational.GE, ArrayLength(Ref("array"))))
.BlockThrow(
NewInstance(
typeof(EPException),
Concat(
Constant("Array length "),
ArrayLength(Ref("array")),
Constant(" less than index "),
Ref("index"),
Constant(" for property '" + _propertyName + "'"))))
.MethodReturn(CodegenLegoCast.CastSafeFromObjectType(
typeof(EventBean), ArrayAtIndex(
Ref("array"), Unbox(Ref("index")))));
return(LocalMethod(method));
}
public CodegenExpression EvaluateGetEventBeanCodegen(CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope)
{
var method = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
method.Block
.DeclareVar <EventBean>("@event", ArrayAtIndex(exprSymbol.GetAddEPS(method), Constant(_streamId)))
.IfRefNullReturnNull("@event")
.MethodReturn(Cast(typeof(EventBean), _getterSpi.EventBeanFragmentCodegen(Ref("@event"), method, codegenClassScope)));
return(LocalMethod(method));
}
public CodegenExpression EvaluateGetEventBeanCodegen(
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
typeof(PropertyDotEventSingleForge),
codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar<EventBean>("@event", ArrayAtIndex(refEPS, Constant(streamId)))
.IfRefNullReturnNull("@event")
.MethodReturn(
Cast(
typeof(EventBean),
getter.EventBeanFragmentCodegen(Ref("@event"), methodNode, codegenClassScope)));
return LocalMethod(methodNode);
}
public CodegenExpression EvaluateGetEventBeanCodegen(
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod method = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
method.Block
.DeclareVar <EventBean>("@event", ExprDotName(exprSymbol.GetAddExprEvalCtx(method), "ContextProperties"))
.IfRefNullReturnNull("@event")
.MethodReturn(Cast(typeof(EventBean), _getterSpi.EventBeanFragmentCodegen(Ref("@event"), method, codegenClassScope)));
return(LocalMethod(method));
}
public CodegenExpression Codegen(
CodegenExpression inner,
Type innerType,
CodegenMethodScope parent,
ExprForgeCodegenSymbol symbols,
CodegenClassScope classScope)
{
var type = EPTypeHelper.GetCodegenReturnType(_returnType);
if (innerType == typeof(EventBean))
{
return(CodegenLegoCast.CastSafeFromObjectType(type, _getter.EventBeanFragmentCodegen(inner, parent, classScope)));
}
var methodNode = parent.MakeChild(type, typeof(ExprDotForgePropertyFragment), classScope).AddParam(innerType, "target");
methodNode.Block
.IfInstanceOf("target", typeof(EventBean))
.BlockReturn(
CodegenLegoCast.CastSafeFromObjectType(type, _getter.EventBeanFragmentCodegen(Cast(typeof(EventBean), inner), methodNode, classScope)))
.MethodReturn(ConstantNull());
return(LocalMethod(methodNode, inner));
}
public static CodegenMethod GetArrayPropertyFragmentCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope,
int index,
EventPropertyGetterSPI nestedGetter)
{
return codegenMethodScope.MakeChild(typeof(object), typeof(BaseNestableEventUtil), codegenClassScope)
.AddParam(typeof(EventBean[]), "wrapper")
.Block
.IfRefNullReturnNull("wrapper")
.IfConditionReturnConst(Relational(ArrayLength(Ref("wrapper")), LE, Constant(index)), null)
.DeclareVar<EventBean>("inner", ArrayAtIndex(Ref("wrapper"), Constant(index)))
.MethodReturn(
nestedGetter.EventBeanFragmentCodegen(Ref("inner"), codegenMethodScope, codegenClassScope));
}
private CodegenMethod GetFragmentCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope)
.AddParam(typeof(IDictionary<string, object>), "map")
.Block
.DeclareVar<object>("value", ExprDotMethod(Ref("map"), "Get", Constant(propertyMap)))
.IfRefNullReturnNull("value")
.DeclareVar<EventBean>("theEvent", Cast(typeof(EventBean), Ref("value")))
.MethodReturn(
eventBeanEntryGetter.EventBeanFragmentCodegen(
Ref("theEvent"),
codegenMethodScope,
codegenClassScope));
}
private CodegenMethod GetFragmentCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope)
.AddParam(typeof(EventBean), "theEvent")
.Block
.DeclareVarWCast(typeof(DecoratingEventBean), "wrapperEvent", "theEvent")
.DeclareVar<EventBean>("wrappedEvent", ExprDotName(Ref("wrapperEvent"), "UnderlyingEvent"))
.IfRefNullReturnNull("wrappedEvent")
.MethodReturn(
underlyingGetter.EventBeanFragmentCodegen(
Ref("wrappedEvent"),
codegenMethodScope,
codegenClassScope));
}
private CodegenMethod GetFragmentCodegen(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
return codegenMethodScope.MakeChild(typeof(object), GetType(), codegenClassScope)
.AddParam(typeof(object[]), "array")
.Block
.DeclareVar<object>("value", ArrayAtIndex(Ref("array"), Constant(propertyIndex)))
.IfRefNullReturnNull("value")
.DeclareVarWCast(typeof(EventBean), "theEvent", "value")
.MethodReturn(
eventBeanEntryGetter.EventBeanFragmentCodegen(
Ref("theEvent"),
codegenMethodScope,
codegenClassScope));
}
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);
}
private CodegenExpression CodegenEvaluateInternal(
CodegenExpressionRef @event,
Func<CodegenMethod, CodegenExpressionRef> refExprEvalCtxFunc,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
if (_disablePropertyExpressionEventCollCache) {
var methodNodeX = codegenMethodScope.MakeChild(
typeof(FlexCollection),
typeof(PropertyDotEventCollectionForge),
codegenClassScope)
.AddParam(typeof(EventBean), "@event");
methodNodeX.Block
.DeclareVar<EventBean[]>(
"events",
Cast(
typeof(EventBean[]),
_getter.EventBeanFragmentCodegen(Ref("@event"), methodNodeX, codegenClassScope)))
.IfRefNullReturnNull("events")
.MethodReturn(FlexWrap(Ref("events")));
return LocalMethod(methodNodeX, @event);
}
var methodNode = codegenMethodScope
.MakeChild(typeof(FlexCollection), typeof(PropertyDotEventCollectionForge), codegenClassScope)
.AddParam(typeof(EventBean), "@event");
CodegenExpressionRef refExprEvalCtx = refExprEvalCtxFunc.Invoke(methodNode);
methodNode.Block
.DeclareVar<ExpressionResultCacheForPropUnwrap>(
"cache",
ExprDotMethodChain(refExprEvalCtx)
.Get("ExpressionResultCacheService")
.Get("AllocateUnwrapProp"))
.DeclareVar<ExpressionResultCacheEntryBeanAndCollBean>(
"cacheEntry",
ExprDotMethod(Ref("cache"), "GetPropertyColl", Constant(_propertyNameCache), Ref("@event")))
.IfCondition(NotEqualsNull(Ref("cacheEntry")))
.BlockReturn(ExprDotName(Ref("cacheEntry"), "Result"))
.DeclareVar<EventBean[]>(
"events",
Cast(
typeof(EventBean[]),
_getter.EventBeanFragmentCodegen(Ref("@event"), methodNode, codegenClassScope)))
.DeclareVarNoInit(typeof(FlexCollection), "coll")
.IfRefNull("events")
.AssignRef("coll", ConstantNull())
.IfElse()
.AssignRef("coll", FlexWrap(Ref("events")))
.BlockEnd()
.Expression(
ExprDotMethod(
Ref("cache"),
"SavePropertyColl",
Constant(_propertyNameCache),
Ref("@event"),
Ref("coll")))
.MethodReturn(Ref("coll"));
return LocalMethod(methodNode, @event);
}
public static CodegenMethod From(
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope,
Type expectedUnderlyingType,
EventPropertyGetterSPI innerGetter,
AccessType accessType,
Type generator)
{
var methodNode = codegenMethodScope.MakeChild(
accessType == AccessType.EXISTS ? typeof(bool) : typeof(object),
generator,
codegenClassScope)
.AddParam(typeof(object), "value");
var block = methodNode.Block
.IfInstanceOf("value", typeof(EventBean))
.DeclareVarWCast(typeof(EventBean), "bean", "value");
if (accessType == AccessType.GET)
{
block = block.BlockReturn(
innerGetter.EventBeanGetCodegen(Ref("bean"), codegenMethodScope, codegenClassScope));
}
else if (accessType == AccessType.EXISTS)
{
block = block.BlockReturn(
innerGetter.EventBeanExistsCodegen(Ref("bean"), codegenMethodScope, codegenClassScope));
}
else if (accessType == AccessType.FRAGMENT)
{
block = block.BlockReturn(
innerGetter.EventBeanFragmentCodegen(Ref("bean"), codegenMethodScope, codegenClassScope));
}
else
{
throw new UnsupportedOperationException("Invalid access type " + accessType);
}
block = block
.IfNotInstanceOf("value", expectedUnderlyingType)
.BlockReturn(
accessType == AccessType.EXISTS
? Constant(false)
: ConstantNull());
CodegenExpression expression;
if (accessType == AccessType.GET)
{
expression = innerGetter.UnderlyingGetCodegen(
Cast(expectedUnderlyingType, Ref("value")),
codegenMethodScope,
codegenClassScope);
}
else if (accessType == AccessType.EXISTS)
{
expression = innerGetter.UnderlyingExistsCodegen(
Cast(expectedUnderlyingType, Ref("value")),
codegenMethodScope,
codegenClassScope);
}
else if (accessType == AccessType.FRAGMENT)
{
expression = innerGetter.UnderlyingFragmentCodegen(
Cast(expectedUnderlyingType, Ref("value")),
codegenMethodScope,
codegenClassScope);
}
else
{
throw new UnsupportedOperationException("Invalid access type " + accessType);
}
block.MethodReturn(expression);
return(methodNode);
}
