public object Evaluate(EvaluateParams evaluateParams) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QExprStreamEventMethod(_exprDotNode); } EventBean theEvent = evaluateParams.EventsPerStream[_streamNumber]; if (theEvent == null) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AExprStreamEventMethod(null); } return(null); } if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QExprDotChain(EPTypeHelper.SingleEvent(theEvent.EventType), theEvent, _evaluators); } Object inner = ExprDotNodeUtility.EvaluateChain(_evaluators, theEvent, evaluateParams.EventsPerStream, evaluateParams.IsNewData, evaluateParams.ExprEvaluatorContext); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AExprDotChain(); } if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AExprStreamEventMethod(inner); } return(inner); }
public override CodegenExpression Codegen( EnumForgeCodegenParams args, CodegenMethodScope codegenMethodScope, CodegenClassScope codegenClassScope) { var innerTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(_resultType)); var paramTypes = EnumForgeCodegenNames.PARAMS; var block = codegenMethodScope .MakeChild(innerTypeBoxed, typeof(EnumMinMaxEventsForgeEval), codegenClassScope) .AddParam(paramTypes) .Block .DeclareVar(innerTypeBoxed, "minKey", ConstantNull()); var forEach = block.ForEach(typeof(object), "value", EnumForgeCodegenNames.REF_ENUMCOLL) .IfRefNull("value") .BlockContinue(); forEach.IfCondition(EqualsNull(Ref("minKey"))) .AssignRef("minKey", Cast(innerTypeBoxed, Ref("value"))) .IfElse() .IfCondition( Relational(ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")), _max ? LT : GT, Constant(0))) .AssignRef("minKey", Cast(innerTypeBoxed, Ref("value"))); var method = block.MethodReturn(Ref("minKey")); return LocalMethod(method, args.Expressions); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var initValueParam = bodiesAndParameters[0]; var initValueEval = initValueParam.BodyForge; TypeInfo = EPTypeHelper.SingleValue(initValueEval.EvaluationType.GetBoxedType()); var resultAndAdd = (ExprDotEvalParamLambda) bodiesAndParameters[1]; if (inputEventType != null) { return new EnumAggregateEventsForge( initValueEval, resultAndAdd.BodyForge, resultAndAdd.StreamCountIncoming, (ObjectArrayEventType) resultAndAdd.GoesToTypes[0]); } return new EnumAggregateScalarForge( initValueEval, resultAndAdd.BodyForge, resultAndAdd.StreamCountIncoming, (ObjectArrayEventType) resultAndAdd.GoesToTypes[0], (ObjectArrayEventType) resultAndAdd.GoesToTypes[1]); }
public ExprDotEvalDT( IList <CalendarOp> calendarOps, TimeZoneInfo timeZone, ReformatOp reformatOp, IntervalOp intervalOp, Type inputType, EventType inputEventType) { _evaluator = GetEvaluator(calendarOps, timeZone, inputType, inputEventType, reformatOp, intervalOp); if (intervalOp != null) { _returnType = EPTypeHelper.SingleValue(typeof(bool?)); } else if (reformatOp != null) { _returnType = EPTypeHelper.SingleValue(reformatOp.ReturnType); } else { // only calendar ops if (inputEventType != null) { _returnType = EPTypeHelper.SingleValue( inputEventType.GetPropertyType(inputEventType.StartTimestampPropertyName)); } else { _returnType = EPTypeHelper.SingleValue(inputType); } } }
public ExprDotForgeGetArray( ExprForge index, Type componentType) { IndexExpression = index; TypeInfo = EPTypeHelper.SingleValue(componentType); }
public override EnumEval GetEnumEval(EngineImportService engineImportService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { ExprDotEvalParam initValueParam = bodiesAndParameters[0]; ExprEvaluator initValueEval = initValueParam.BodyEvaluator; base.TypeInfo = EPTypeHelper.SingleValue(initValueEval.ReturnType.GetBoxedType()); var resultAndAdd = (ExprDotEvalParamLambda)bodiesAndParameters[1]; if (inputEventType != null) { return(new EnumEvalAggregateEvents( initValueEval, resultAndAdd.BodyEvaluator, resultAndAdd.StreamCountIncoming, (ObjectArrayEventType)resultAndAdd.GoesToTypes[0])); } else { return(new EnumEvalAggregateScalar( initValueEval, resultAndAdd.BodyEvaluator, resultAndAdd.StreamCountIncoming, (ObjectArrayEventType)resultAndAdd.GoesToTypes[0], (ObjectArrayEventType)resultAndAdd.GoesToTypes[1])); } }
public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { ExprEvaluator sizeEval = bodiesAndParameters[0].BodyEvaluator; if (inputEventType != null) { base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); } if (EnumMethodEnum == EnumMethodEnum.TAKE) { return(new EnumEvalTake(sizeEval, numStreamsIncoming)); } else { return(new EnumEvalTakeLast(sizeEval, numStreamsIncoming)); } }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var max = EnumMethodEnum == EnumMethodEnum.MAX; if (bodiesAndParameters.IsEmpty()) { var returnTypeX = Boxing.GetBoxedType(collectionComponentType); TypeInfo = EPTypeHelper.SingleValue(returnTypeX); return new EnumMinMaxScalarForge(numStreamsIncoming, max, TypeInfo); } var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; var returnType = Boxing.GetBoxedType(first.BodyForge.EvaluationType); TypeInfo = EPTypeHelper.SingleValue(returnType); if (inputEventType == null) { return new EnumMinMaxScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, max, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumMinMaxEventsForge(first.BodyForge, first.StreamCountIncoming, max); }
public ExprDotForgeArrayGet( ExprForge index, Type componentType) { this.indexExpression = index; this.typeInfo = EPTypeHelper.SingleValue(componentType); }
public ExprDotNodeForgeStream( ExprDotNodeImpl parent, FilterExprAnalyzerAffector filterExprAnalyzerAffector, int streamNumber, EventType eventType, ExprDotForge[] evaluators, bool method) { this.parent = parent; FilterExprAnalyzerAffector = filterExprAnalyzerAffector; StreamNumber = streamNumber; EventType = eventType; Evaluators = evaluators; this.method = method; var last = evaluators[evaluators.Length - 1]; if (!method) { if (last.TypeInfo is ClassMultiValuedEPType) { EvaluationType = EPTypeHelper.GetClassMultiValuedContainer(last.TypeInfo).GetBoxedType(); } else { EvaluationType = EPTypeHelper.GetClassSingleValued(last.TypeInfo).GetBoxedType(); } } else { EvaluationType = EPTypeHelper.GetNormalizedClass(last.TypeInfo).GetBoxedType(); } }
public override EnumForge GetEnumForge( StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { // TBD: Look at this closer // TypeInfo = EPTypeHelper.SingleValue(typeof(IDictionary<string, object>)); TypeInfo = EPTypeHelper.SingleValue(typeof(IDictionary<object, object>)); var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; var second = (ExprDotEvalParamLambda) bodiesAndParameters[1]; if (inputEventType == null) { return new EnumToMapScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, second.BodyForge, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumToMapEventsForge(first.BodyForge, first.StreamCountIncoming, second.BodyForge); }
public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; var max = EnumMethodEnum == EnumMethodEnum.MAXBY; if (inputEventType == null) { base.TypeInfo = EPTypeHelper.SingleValue(collectionComponentType); return(new EnumEvalMinMaxByScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, max, (ObjectArrayEventType)first.GoesToTypes[0])); } base.TypeInfo = EPTypeHelper.SingleEvent(inputEventType); return(new EnumEvalMinMaxByEvents(first.BodyEvaluator, first.StreamCountIncoming, max)); }
public override EnumEval GetEnumEval(MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { Type returnType; if (bodiesAndParameters.IsEmpty()) { returnType = collectionComponentType.GetBoxedType(); base.TypeInfo = EPTypeHelper.SingleValue(returnType); return(new EnumEvalMostLeastFrequentScalar( numStreamsIncoming, EnumMethodEnum == EnumMethodEnum.MOSTFREQUENT)); } var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; returnType = first.BodyEvaluator.ReturnType.GetBoxedType(); base.TypeInfo = EPTypeHelper.SingleValue(returnType); var mostFrequent = EnumMethodEnum == EnumMethodEnum.MOSTFREQUENT; if (inputEventType == null) { return(new EnumEvalMostLeastFrequentScalarLamda( first.BodyEvaluator, first.StreamCountIncoming, mostFrequent, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalMostLeastFrequentEvent(first.BodyEvaluator, numStreamsIncoming, mostFrequent)); }
public override EnumEval GetEnumEval(MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (inputEventType != null) { TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); if (first.GoesToNames.Count == 1) { return(new EnumEvalWhereEvents(first.BodyEvaluator, first.StreamCountIncoming)); } return(new EnumEvalWhereIndexEvents( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[1])); } TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); if (first.GoesToNames.Count == 1) { return(new EnumEvalWhereScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalWhereScalarIndex( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0], (ObjectArrayEventType)first.GoesToTypes[1])); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; TypeInfo = EPTypeHelper.SingleValue(typeof(bool?)); if (inputEventType != null) { if (EnumMethodEnum == EnumMethodEnum.ALLOF) { return new EnumAllOfEventsForge(first.BodyForge, first.StreamCountIncoming); } return new EnumAnyOfEventsForge(first.BodyForge, first.StreamCountIncoming); } if (EnumMethodEnum == EnumMethodEnum.ALLOF) { return new EnumAllOfScalarForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumAnyOfScalarForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0]); }
public CodegenExpression Codegen(CodegenExpression inner, Type innerType, CodegenMethodScope parent, ExprForgeCodegenSymbol symbols, CodegenClassScope classScope) { Type type = EPTypeHelper.GetCodegenReturnType(_returnType); CodegenMethod method = parent .MakeChild(type, typeof(ExprDotForgeProperty), classScope) .AddParam(innerType, "target").AddParam(typeof(int?), "index"); var arrayExpr = CastSafeFromObjectType(_arrayType, _getter.EventBeanGetCodegen(Cast(typeof(EventBean), Ref("target")), method, classScope)); method.Block .IfNotInstanceOf("target", typeof(EventBean)) .BlockReturn(ConstantNull()) .DeclareVar(_arrayType, "array", arrayExpr) .IfRefNullReturnNull("index") .IfCondition(Relational(Ref("index"), CodegenExpressionRelational.CodegenRelational.GE, ArrayLength(Ref("array")))) .BlockThrow( NewInstance <EPException>( Concat( Constant("Array length "), ArrayLength(Ref("array")), Constant(" less than index "), Ref("index"), Constant(" for property '" + _propertyName + "'")))) .MethodReturn(CastSafeFromObjectType(type, ArrayAtIndex(Ref("array"), ExprDotMethod(Ref("index"), "AsInt32")))); return(LocalMethod(method, inner, _indexExpression.Forge.EvaluateCodegen(typeof(int?), method, symbols, classScope))); }
public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { bool isDescending = EnumMethodEnum == EnumMethodEnum.ORDERBYDESC; if (bodiesAndParameters.IsEmpty()) { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); return(new EnumEvalOrderByAscDescScalar(numStreamsIncoming, isDescending)); } var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (inputEventType == null) { base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType); return(new EnumEvalOrderByAscDescScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, isDescending, (ObjectArrayEventType)first.GoesToTypes[0])); } base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); return(new EnumEvalOrderByAscDescEvents(first.BodyEvaluator, first.StreamCountIncoming, isDescending)); }
public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { if (bodiesAndParameters.IsEmpty()) { var aggMethodFactoryX = GetAggregatorFactory(collectionComponentType); TypeInfo = EPTypeHelper.SingleValue(aggMethodFactoryX.ValueType.GetBoxedType()); return(new EnumEvalSumScalar(numStreamsIncoming, aggMethodFactoryX)); } var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; var aggMethodFactory = GetAggregatorFactory(first.BodyEvaluator.ReturnType); var returnType = aggMethodFactory.ValueType.GetBoxedType(); TypeInfo = EPTypeHelper.SingleValue(returnType); if (inputEventType == null) { return(new EnumEvalSumScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, aggMethodFactory, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalSumEvents(first.BodyEvaluator, first.StreamCountIncoming, aggMethodFactory)); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var isDescending = EnumMethodEnum == EnumMethodEnum.ORDERBYDESC; if (bodiesAndParameters.IsEmpty()) { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); return new EnumOrderByAscDescScalarForge(numStreamsIncoming, isDescending); } var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; if (inputEventType == null) { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); return new EnumOrderByAscDescScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, isDescending, (ObjectArrayEventType) first.GoesToTypes[0]); } TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); return new EnumOrderByAscDescEventsForge(first.BodyForge, first.StreamCountIncoming, isDescending); }
public ExprDotForgeUnpackBeanTable( EventType lambdaType, TableMetaData tableMetadata) { this.tableMetadata = tableMetadata; this.returnType = EPTypeHelper.SingleValue(tableMetadata.PublicEventType.UnderlyingType); }
public override EnumEval GetEnumEval( MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, String statementId, String enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; TypeInfo = EPTypeHelper.SingleValue(typeof(bool)); if (inputEventType != null) { if (EnumMethodEnum == EnumMethodEnum.ALLOF) { return(new EnumEvalAllOfEvents(first.BodyEvaluator, first.StreamCountIncoming)); } return(new EnumEvalAnyOfEvents(first.BodyEvaluator, first.StreamCountIncoming)); } if (EnumMethodEnum == EnumMethodEnum.ALLOF) { return(new EnumEvalAllOfScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalAnyOfScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); }
public override EnumEval GetEnumEval(EngineImportService engineImportService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { bool max = this.EnumMethodEnum == EnumMethodEnum.MAX; Type returnType; if (bodiesAndParameters.IsEmpty()) { returnType = collectionComponentType.GetBoxedType(); base.TypeInfo = EPTypeHelper.SingleValue(returnType); return(new EnumEvalMinMaxScalar(numStreamsIncoming, max)); } var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; returnType = first.BodyEvaluator.ReturnType.GetBoxedType(); base.TypeInfo = EPTypeHelper.SingleValue(returnType); if (inputEventType == null) { return(new EnumEvalMinMaxScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, max, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalMinMaxEvents(first.BodyEvaluator, first.StreamCountIncoming, max)); }
public static CodegenExpression Codegen( ExprDotForgeGetCollection forge, CodegenExpression inner, Type innerType, CodegenMethodScope codegenMethodScope, ExprForgeCodegenSymbol exprSymbol, CodegenClassScope codegenClassScope) { var methodNode = codegenMethodScope.MakeChild( forge.TypeInfo.GetNormalizedClass(), typeof(ExprDotForgeGetCollectionEval), codegenClassScope) .AddParam(innerType, "target"); var block = methodNode.Block; if (!innerType.IsPrimitive) { block.IfRefNullReturnNull("target"); } var targetType = EPTypeHelper.GetCodegenReturnType(forge.TypeInfo); block.DeclareVar <int>("index", forge.IndexExpression.EvaluateCodegen(typeof(int), methodNode, exprSymbol, codegenClassScope)) .MethodReturn( CodegenLegoCast.CastSafeFromObjectType( targetType, StaticMethod( typeof(ExprDotForgeGetCollectionEval), "CollectionElementAt", Ref("target"), Ref("index")))); return(LocalMethod(methodNode, inner)); }
public override EnumEval GetEnumEval(MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { base.TypeInfo = EPTypeHelper.SingleValue(typeof(Boolean)); ExprEvaluator body = bodiesAndParameters[0].BodyEvaluator; return(new EnumEvalSequenceEqual(body, numStreamsIncoming)); }
protected override EPType InitAndNoParamsReturnType( EventType inputEventType, Type collectionComponentType) { aggMethodFactory = GetAggregatorFactory(collectionComponentType); return(EPTypeHelper.SingleValue(Boxing.GetBoxedType(aggMethodFactory.ValueType))); }
public ExprDotDTForge( IList<CalendarForge> calendarForges, TimeAbacus timeAbacus, ReformatForge reformatForge, IntervalForge intervalForge, Type inputType, EventType inputEventType) { if (intervalForge != null) { TypeInfo = EPTypeHelper.SingleValue(typeof(bool?)); } else if (reformatForge != null) { TypeInfo = EPTypeHelper.SingleValue(reformatForge.ReturnType); } else { // only calendar op if (inputEventType != null) { TypeInfo = EPTypeHelper.SingleValue( inputEventType.GetPropertyType(inputEventType.StartTimestampPropertyName)); } else { TypeInfo = EPTypeHelper.SingleValue(inputType); } } forge = GetForge(calendarForges, timeAbacus, inputType, inputEventType, reformatForge, intervalForge); }
public override EnumForge GetEnumForge( StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { if (bodiesAndParameters.IsEmpty()) { var aggMethodFactoryInner = GetAggregatorFactory(collectionComponentType); TypeInfo = EPTypeHelper.SingleValue(aggMethodFactoryInner.ValueType.GetBoxedType()); return new EnumSumScalarForge(numStreamsIncoming, aggMethodFactoryInner); } var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; var aggMethodFactory = GetAggregatorFactory(first.BodyForge.EvaluationType); var returnType = aggMethodFactory.ValueType.GetBoxedType(); TypeInfo = EPTypeHelper.SingleValue(returnType); if (inputEventType == null) { return new EnumSumScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, aggMethodFactory, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumSumEventsForge(first.BodyForge, first.StreamCountIncoming, aggMethodFactory); }
public override EnumEval GetEnumEval(MethodResolutionService methodResolutionService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache) { base.TypeInfo = EPTypeHelper.SingleValue(typeof(GroupMap)); var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (bodiesAndParameters.Count == 2) { var second = (ExprDotEvalParamLambda)bodiesAndParameters[1]; if (inputEventType == null) { return(new EnumEvalGroupByKeyValueSelectorScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, second.BodyEvaluator, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalGroupByKeyValueSelectorEvents( first.BodyEvaluator, first.StreamCountIncoming, second.BodyEvaluator)); } if (inputEventType == null) { return(new EnumEvalGroupByKeySelectorScalarLambda( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } return(new EnumEvalGroupByKeySelectorEvents(first.BodyEvaluator, first.StreamCountIncoming)); }
public override EnumForge GetEnumForge(StreamTypeService streamTypeService, string enumMethodUsedName, IList<ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var sizeEval = bodiesAndParameters[0].BodyForge; if (inputEventType != null) { TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType); } else { TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null); } if (EnumMethodEnum == EnumMethodEnum.TAKE) { return new EnumTakeForge(sizeEval, numStreamsIncoming, inputEventType == null); } else { return new EnumTakeLastForge(sizeEval, numStreamsIncoming, inputEventType == null); } }
protected override EPType InitAndNoParamsReturnType( EventType inputEventType, Type collectionComponentType) { var returnType = collectionComponentType.GetBoxedType(); return(EPTypeHelper.SingleValue(returnType)); }