public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var manufacturerField = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
manufacturer.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
var refEPS = exprSymbol.GetAddEPS(methodNode);
var block = methodNode.Block
.DeclareVar<ObjectArrayBackedEventBean>(
"theEvent",
Cast(
typeof(ObjectArrayBackedEventBean),
ArrayAtIndex(refEPS, Constant(underlyingStreamNumber))))
.DeclareVar<object[]>("props", NewArrayByLength(typeof(object), Constant(items.Length)));
foreach (var item in items) {
if (item.OptionalFromIndex != -1) {
block.AssignArrayElement(
"props",
Constant(item.ToIndex),
ArrayAtIndex(
ExprDotName(Ref("theEvent"), "Properties"),
Constant(item.OptionalFromIndex)));
}
else {
CodegenExpression value;
if (item.OptionalWidener != null) {
value = item.Forge.EvaluateCodegen(
item.Forge.EvaluationType,
methodNode,
exprSymbol,
codegenClassScope);
value = item.OptionalWidener.WidenCodegen(value, methodNode, codegenClassScope);
}
else {
value = item.Forge.EvaluateCodegen(
typeof(object),
methodNode,
exprSymbol,
codegenClassScope);
}
block.AssignArrayElement("props", Constant(item.ToIndex), value);
}
}
block.MethodReturn(ExprDotMethod(manufacturerField, "Make", Ref("props")));
return methodNode;
}
public SAIFFInitializeBuilder Manufacturer(
string name,
EventBeanManufacturerForge forge)
{
if (forge == null) {
return SetValue(name, ConstantNull());
}
var manufacturer = classScope.AddDefaultFieldUnshared<EventBeanManufacturer>(
true, forge.Make(method.Block, method, classScope));
return SetValue(name, manufacturer);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ContainedEventEvalArrayToEvent), GetType(), classScope);
CodegenExpression eval = ExprNodeUtilityCodegen.CodegenEvaluator(evaluator, method, GetType(), classScope);
method.Block
.DeclareVar<EventBeanManufacturer>("manu", manufacturer.Make(method.Block, method, classScope))
.MethodReturn(NewInstance<ContainedEventEvalArrayToEvent>(eval, Ref("manu")));
return LocalMethod(method);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var manufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
eventManufacturer.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
methodNode.Block.MethodReturn(
CodegenExpressionBuilder.ExprDotMethod(
manufacturer,
"Make",
CodegenExpressionBuilder.PublicConstValue(typeof(CollectionUtil), "OBJECTARRAY_EMPTY")));
return(methodNode);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (singleRowOnly) {
var singleMethodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
typeof(SelectExprProcessorTypableSingleForge),
codegenClassScope);
var singleMethodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(singleMethodNode.Block, codegenMethodScope, codegenClassScope));
var singleMethodBlock = singleMethodNode.Block
.DeclareVar<object[]>(
"row",
typable.EvaluateTypableSingleCodegen(singleMethodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("row");
if (hasWideners) {
singleMethodBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegen(
Ref("row"),
wideners,
singleMethodNode,
codegenClassScope));
}
singleMethodBlock.MethodReturn(ExprDotMethod(singleMethodManufacturer, "Make", Ref("row")));
return LocalMethod(singleMethodNode);
}
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean[]),
typeof(SelectExprProcessorTypableSingleForge),
codegenClassScope);
var methodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
var methodBlock = methodNode.Block
.DeclareVar<object[]>(
"row",
typable.EvaluateTypableSingleCodegen(methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("row");
if (hasWideners) {
methodBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegen(
Ref("row"),
wideners,
methodNode,
codegenClassScope));
}
methodBlock.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), Constant(1)))
.AssignArrayElement("events", Constant(0), ExprDotMethod(methodManufacturer, "Make", Ref("row")))
.MethodReturn(Ref("events"));
return LocalMethod(methodNode);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (firstRowOnly) {
var firstMethodNode = codegenMethodScope
.MakeChild(typeof(EventBean), typeof(SelectExprProcessorTypableMultiForge), codegenClassScope);
var firstMethodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(firstMethodNode.Block, codegenMethodScope, codegenClassScope));
var firstBlock = firstMethodNode.Block
.DeclareVar<object[]>(
"row",
typable.EvaluateTypableSingleCodegen(firstMethodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("row");
if (hasWideners) {
firstBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegen(
Ref("row"),
wideners,
firstMethodNode,
codegenClassScope));
}
firstBlock.MethodReturn(ExprDotMethod(firstMethodManufacturer, "Make", Ref("row")));
return LocalMethod(firstMethodNode);
}
else {
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean[]),
typeof(SelectExprProcessorTypableMultiForge),
codegenClassScope);
var methodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
var methodBlock = methodNode.Block
.DeclareVar<object[][]>(
"rows",
typable.EvaluateTypableMultiCodegen(methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("rows")
.IfCondition(EqualsIdentity(ArrayLength(Ref("rows")), Constant(0)))
.BlockReturn(NewArrayByLength(typeof(EventBean), Constant(0)));
if (hasWideners) {
methodBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegenMultirow(
Ref("rows"),
wideners,
methodNode,
codegenClassScope));
}
methodBlock.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), ArrayLength(Ref("rows"))))
.ForLoopIntSimple("i", ArrayLength(Ref("events")))
.AssignArrayElement(
"events",
Ref("i"),
ExprDotMethod(methodManufacturer, "Make", ArrayAtIndex(Ref("rows"), Ref("i"))))
.BlockEnd()
.MethodReturn(Ref("events"));
return LocalMethod(methodNode);
}
}
