public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
var mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(resultEventType, EPStatementInitServicesConstants.REF));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar(resultEventType.UnderlyingType, "tuple", NewInstanceInner(resultEventType.Detail.UnderlyingClassName));
for (var i = 0; i < streamNames.Length; i++) {
var @event = ArrayAtIndex(refEPS, Constant(i));
var field = resultEventType.Detail.FieldDescriptors.Get(streamNames[i]);
var rhs = Cast(field.PropertyType, ExprDotUnderlying(@event));
methodNode.Block.AssignRef(ExprDotName(Ref("tuple"), field.FieldName), rhs);
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("tuple"), mType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenBlock block = methodNode.Block
.DeclareVar<object[]>(
"props",
NewArrayByLength(typeof(object), Constant(this.context.ExprForges.Length)));
for (int i = 0; i < this.context.ExprForges.Length; i++) {
CodegenExpression expression = CodegenLegoMayVoid.ExpressionMayVoid(
typeof(object),
this.context.ExprForges[i],
methodNode,
exprSymbol,
codegenClassScope);
block.AssignArrayElement("props", Constant(i), expression);
}
block.MethodReturn(
ExprDotMethod(eventBeanFactory, "AdapterForTypedObjectArray", Ref("props"), resultEventType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
var mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(_resultEventTypeAvro, EPStatementInitServicesConstants.REF));
var schema = codegenClassScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(RecordSchema),
CodegenExpressionBuilder.StaticMethod(
typeof(AvroSchemaUtil),
"ResolveRecordSchema",
EventTypeUtility.ResolveTypeCodegen(_resultEventTypeAvro, EPStatementInitServicesConstants.REF)));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block.MethodReturn(
CodegenExpressionBuilder.StaticMethod(
typeof(SelectExprJoinWildcardProcessorAvro),
"ProcessSelectExprJoinWildcardAvro",
refEPS,
schema,
eventBeanFactory,
mType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
var mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(ResultEventType, EPStatementInitServicesConstants.REF));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar<object[]>("tuple", NewArrayByLength(typeof(object), Constant(streamNames.Length)))
.StaticMethod(
typeof(Array),
"Copy",
refEPS,
Constant(0),
Ref("tuple"),
Constant(0),
Constant(streamNames.Length))
.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedObjectArray", Ref("tuple"), mType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
var codegenPropsRef = Ref("props");
methodNode.Block.DeclareVar<IDictionary<string, object>>(
"props",
NewInstance(typeof(HashMap<string, object>)));
for (int i = 0; i < selectContext.ColumnNames.Length; i++) {
var selectContextExprForge = selectContext.ExprForges[i];
var expression = CodegenLegoMayVoid.ExpressionMayVoid(
typeof(object),
selectContextExprForge,
methodNode,
exprSymbol,
codegenClassScope);
var codegenValue = Constant(selectContext.ColumnNames[i]);
methodNode.Block.Expression(
ExprDotMethod(codegenPropsRef, "Put", codegenValue, expression));
}
methodNode.Block.MethodReturn(
ExprDotMethod(eventBeanFactory, "AdapterForTypedMap", Ref("props"), resultEventType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), this.GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar(resultType.UnderlyingType, "und", NewInstance(resultType.UnderlyingType))
.DeclareVar(
sourceType.UnderlyingType,
"src",
CastUnderlying(sourceType.UnderlyingType, ArrayAtIndex(refEPS, Constant(underlyingStreamNumber))));
foreach (var sourceFieldEntry in sourceType.Detail.FieldDescriptors)
{
var targetField = resultType.Detail.FieldDescriptors.Get(sourceFieldEntry.Key);
methodNode.Block.AssignRef("und." + targetField.FieldName, Ref("src." + sourceFieldEntry.Value.FieldName));
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("und"), resultEventType));
return(methodNode);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventTypeOuter,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
// NOTE: Maintaining result-event-type as out own field as we may be an "inner" select-expr-processor
CodegenExpressionInstanceField mType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(resultEventType, EPStatementInitServicesConstants.REF));
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block.DeclareVar<IDictionary<string, object>>(
"tuple", NewInstance(typeof(HashMap<string, object>)));
for (int i = 0; i < streamNames.Length; i++) {
methodNode.Block.Expression(
ExprDotMethod(Ref("tuple"), "Put", Constant(streamNames[i]), ArrayAtIndex(refEPS, Constant(i))));
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedMap", Ref("tuple"), mType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(typeof(EventBean), this.GetType(), codegenClassScope);
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
methodNode.Block
.DeclareVar(source.Detail.UnderlyingClassName, "src", CastUnderlying(source.Detail.UnderlyingClassName, ArrayAtIndex(refEPS, Constant(0))))
.DeclareVar(target.Detail.UnderlyingClassName, "und", NewInstanceInner(target.Detail.UnderlyingClassName));
foreach (var entryTarget in target.Detail.FieldDescriptors)
{
var src = source.Detail.FieldDescriptors.Get(entryTarget.Key);
if (src == null)
{
continue;
}
methodNode.Block.AssignRef("und." + entryTarget.Value.FieldName, Ref("src." + src.FieldName));
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("und"), resultEventType));
return(methodNode);
}
public abstract CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope);
protected abstract CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope);
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;
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var variantType = VariantEventTypeUtil.GetField(variantEventType, codegenClassScope);
var innerType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(innerEventType, EPStatementInitServicesConstants.REF));
CodegenExpression inner = ExprDotMethod(eventBeanFactory, "AdapterForTypedMap", props, innerType);
return ExprDotMethod(variantType, "GetValueAddEventBean", inner);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var value = ExprDotName(
Cast(typeof(ObjectArrayBackedEventBean), ArrayAtIndex(refEPS, Constant(underlyingStreamNumber))),
"Properties");
methodNode.Block.MethodReturn(
ExprDotMethod(eventBeanFactory, "AdapterForTypedObjectArray", value, resultEventType));
return methodNode;
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
return ExprDotMethod(
eventBeanFactory,
"AdapterForTypedWrapper",
ArrayAtIndex(refEPS, Constant(0)),
props,
resultEventType);
}
public override CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var size = ComputeSize();
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var block = methodNode.Block
.DeclareVar<object[]>("props", NewArrayByLength(typeof(object), Constant(size)));
var count = 0;
foreach (var forge in context.ExprForges) {
block.AssignArrayElement(
Ref("props"),
Constant(count),
CodegenLegoMayVoid.ExpressionMayVoid(
typeof(object),
forge,
methodNode,
exprSymbol,
codegenClassScope));
count++;
}
foreach (var element in namedStreams) {
var theEvent = ArrayAtIndex(refEPS, Constant(element.StreamNumber));
block.AssignArrayElement(Ref("props"), Constant(count), theEvent);
count++;
}
if (isUsingWildcard && context.NumStreams > 1) {
for (var i = 0; i < context.NumStreams; i++) {
block.AssignArrayElement(Ref("props"), Constant(count), ArrayAtIndex(refEPS, Constant(i)));
count++;
}
}
block.MethodReturn(
ProcessSpecificCodegen(resultEventType, eventBeanFactory, Ref("props"), codegenClassScope));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var type = VariantEventTypeUtil.GetField(variantEventType, codegenClassScope);
methodNode.Block.MethodReturn(
ExprDotMethod(type, "GetValueAddEventBean", ArrayAtIndex(refEPS, Constant(0))));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
CodegenExpression bean = ExprDotName(ArrayAtIndex(refEPS, Constant(streamNumber)), "Underlying");
methodNode.Block.MethodReturn(
ExprDotMethod(eventBeanFactory, "AdapterForTypedObject", bean, resultEventType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenBlock block = methodNode.Block;
if (this.context.ExprForges.Length == 0) {
block.DeclareVar<IDictionary<string, object>>(
"props", StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(string), typeof(object) }));
}
else {
block.DeclareVar<IDictionary<string, object>>(
"props", NewInstance(typeof(HashMap<string, object>)));
}
for (int i = 0; i < this.context.ColumnNames.Length; i++) {
CodegenExpression expression = CodegenLegoMayVoid.ExpressionMayVoid(
typeof(object),
this.context.ExprForges[i],
methodNode,
exprSymbol,
codegenClassScope);
block.Expression(
ExprDotMethod(Ref("props"), "Put", Constant(this.context.ColumnNames[i]), expression));
}
block.MethodReturn(
ProcessSpecificCodegen(
resultEventType,
eventBeanFactory,
Ref("props"),
methodNode,
selectSymbol,
exprSymbol,
codegenClassScope));
return methodNode;
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
return StaticMethod(
typeof(SelectEvalInsertWildcardSSWrapper),
"ProcessSelectExprSSWrapper",
props,
refEPS,
Constant(context.ExprForges.Length == 0),
eventBeanFactory,
resultEventType);
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var type = VariantEventTypeUtil.GetField(variantEventType, codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
return StaticMethod(
typeof(SelectEvalInsertWildcardSSWrapperRevision),
"SelectExprInsertWildcardSSWrapRevision",
refEPS,
evaluators == null ? Constant(0) : Constant(evaluators.Length),
props,
type);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), this.GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var block = methodNode.Block
.DeclareVar(
sourceType.UnderlyingType,
"src",
CastUnderlying(sourceType.UnderlyingType, ArrayAtIndex(refEPS, Constant(underlyingStreamNumber))))
.DeclareVar(resultType.UnderlyingType, "und", NewInstance(resultType.UnderlyingType));
foreach (var item in items)
{
if (item.OptionalFromField != null)
{
block.AssignRef("und." + item.ToField.FieldName, Ref("src." + item.OptionalFromField.FieldName));
}
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.AssignRef("und." + item.ToField.FieldName, value);
}
}
methodNode.Block.MethodReturn(ExprDotMethod(eventBeanFactory, "AdapterForTypedJson", Ref("und"), resultEventType));
return(methodNode);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
methodNode.Block.MethodReturn(
ExprDotMethod(
eventBeanFactory,
"AdapterForTypedMap",
StaticMethod(typeof(Collections), "GetEmptyMap", new[] { typeof(object), typeof(object) }),
resultEventType));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var theEvent = CodegenExpressionBuilder.Cast(
typeof(AvroGenericDataBackedEventBean),
CodegenExpressionBuilder.ArrayAtIndex(
refEPS,
CodegenExpressionBuilder.Constant(_underlyingStreamNumber)));
methodNode.Block.MethodReturn(
CodegenExpressionBuilder.ExprDotMethod(
eventBeanFactory,
"AdapterForTypedAvro",
CodegenExpressionBuilder.ExprDotName(theEvent, "Properties"),
resultEventType));
return methodNode;
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod inner = joinWildcardProcessorForge.ProcessCodegen(
resultEventType,
eventBeanFactory,
methodNode,
selectEnv,
exprSymbol,
codegenClassScope);
return ExprDotMethod(
eventBeanFactory,
"AdapterForTypedWrapper",
LocalMethod(inner),
props,
resultEventType);
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var innerType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(innerWrapperType, EPStatementInitServicesConstants.REF));
var refEPS = exprSymbol.GetAddEPS(methodNode);
return StaticMethod(
this.GetType(),
"WildcardNestedWrapper",
ArrayAtIndex(refEPS, Constant(0)),
innerType,
resultEventType,
eventBeanFactory,
props);
}
protected override CodegenExpression ProcessSpecificCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenExpression props,
CodegenMethod methodNode,
SelectExprProcessorCodegenSymbol selectEnv,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var type = VariantEventTypeUtil.GetField(variantEventType, codegenClassScope);
var innerType = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventType),
EventTypeUtility.ResolveTypeCodegen(wrappingEventType, EPStatementInitServicesConstants.REF));
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
CodegenExpression wrapped = ExprDotMethod(
eventBeanFactory,
"AdapterForTypedWrapper",
ArrayAtIndex(refEPS, Constant(0)),
Ref("props"),
innerType);
return ExprDotMethod(type, "GetValueAddEventBean", wrapped);
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var variantType = VariantEventTypeUtil.GetField(variantEventType, codegenClassScope);
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
var jw = joinWildcardProcessorForge.ProcessCodegen(
resultEventType,
eventBeanFactory,
methodNode,
selectSymbol,
exprSymbol,
codegenClassScope);
methodNode.Block.MethodReturn(ExprDotMethod(variantType, "GetValueAddEventBean", LocalMethod(jw)));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenExpressionInstanceField eventToPublic =
TableDeployTimeResolver.MakeTableEventToPublicField(table, codegenClassScope, this.GetType());
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
CodegenExpressionRef refEPS = exprSymbol.GetAddEPS(methodNode);
CodegenExpression refIsNewData = exprSymbol.GetAddIsNewData(methodNode);
CodegenExpressionRef refExprEvalCtx = exprSymbol.GetAddExprEvalCtx(methodNode);
methodNode.Block
.DeclareVar<EventBean>("@event", ArrayAtIndex(refEPS, Constant(0)))
.IfRefNullReturnNull("@event")
.MethodReturn(
ExprDotMethod(eventToPublic, "Convert", Ref("@event"), refEPS, refIsNewData, refExprEvalCtx));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
CodegenMethod methodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
this.GetType(),
codegenClassScope);
ExprForge first = selectExprForgeContext.ExprForges[0];
Type evaluationType = first.EvaluationType;
methodNode.Block.MethodReturn(
ProcessFirstColCodegen(
evaluationType,
first.EvaluateCodegen(evaluationType, methodNode, exprSymbol, codegenClassScope),
resultEventType,
eventBeanFactory,
methodNode,
codegenClassScope));
return methodNode;
}
public CodegenMethod ProcessCodegen(
CodegenExpression resultEventType,
CodegenExpression eventBeanFactory,
CodegenMethodScope codegenMethodScope,
SelectExprProcessorCodegenSymbol selectSymbol,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var schema = codegenClassScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(RecordSchema),
CodegenExpressionBuilder.StaticMethod(
typeof(AvroSchemaUtil),
"ResolveRecordSchema",
EventTypeUtility.ResolveTypeCodegen(ResultEventType, EPStatementInitServicesConstants.REF)));
var methodNode = codegenMethodScope.MakeChild(typeof(EventBean), GetType(), codegenClassScope);
var refEPS = exprSymbol.GetAddEPS(methodNode);
var block = methodNode.Block
.DeclareVar<AvroGenericDataBackedEventBean>(
"theEvent",
CodegenExpressionBuilder.Cast(
typeof(AvroGenericDataBackedEventBean),
CodegenExpressionBuilder.ArrayAtIndex(
refEPS,
CodegenExpressionBuilder.Constant(_underlyingStreamNumber))))
.DeclareVar<GenericRecord>(
"source",
CodegenExpressionBuilder.ExprDotName(
CodegenExpressionBuilder.Ref("theEvent"),
"Properties"))
.DeclareVar<GenericRecord>(
"target",
CodegenExpressionBuilder.NewInstance(typeof(GenericRecord), schema));
foreach (var item in _items) {
CodegenExpression value;
if (item.OptionalFromIndex != null) {
value = CodegenExpressionBuilder.StaticMethod(
typeof(GenericRecordExtensions),
"Get",
CodegenExpressionBuilder.Ref("source"),
CodegenExpressionBuilder.Constant(item.OptionalFromIndex.Name));
}
else {
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.StaticMethod(
typeof(GenericRecordExtensions),
"Put",
CodegenExpressionBuilder.Ref("target"),
CodegenExpressionBuilder.Constant(item.ToIndex.Name),
value);
}
block.MethodReturn(
CodegenExpressionBuilder.ExprDotMethod(
eventBeanFactory,
"AdapterForTypedAvro",
CodegenExpressionBuilder.Ref("target"),
resultEventType));
return methodNode;
}
