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 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) { // 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 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 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 ExprDotForgeArrayGet( ExprForge index, Type componentType) { this.indexExpression = index; this.typeInfo = EPTypeHelper.SingleValue(componentType); }
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 ExprDotForgeUnpackBeanTable( EventType lambdaType, TableMetaData tableMetadata) { this.tableMetadata = tableMetadata; this.returnType = EPTypeHelper.SingleValue(tableMetadata.PublicEventType.UnderlyingType); }
public ExprDotForgeGetArray( ExprForge index, Type componentType) { IndexExpression = index; TypeInfo = EPTypeHelper.SingleValue(componentType); }
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)); }
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 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) { 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(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 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); } } }
protected override EPType InitAndNoParamsReturnType( EventType inputEventType, Type collectionComponentType) { aggMethodFactory = GetAggregatorFactory(collectionComponentType); return(EPTypeHelper.SingleValue(Boxing.GetBoxedType(aggMethodFactory.ValueType))); }
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 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]); }
protected override EPType InitAndNoParamsReturnType( EventType inputEventType, Type collectionComponentType) { var returnType = collectionComponentType.GetBoxedType(); return(EPTypeHelper.SingleValue(returnType)); }
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()) { if (inputEventType != null) { base.TypeInfo = EPTypeHelper.SingleEvent(inputEventType); } else { base.TypeInfo = EPTypeHelper.SingleValue(collectionComponentType); } if (EnumMethodEnum == EnumMethodEnum.FIRST) { return(new EnumEvalFirstOfNoPredicate(numStreamsIncoming)); } else { return(new EnumEvalLastOfNoPredicate(numStreamsIncoming)); } } var first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; if (inputEventType != null) { base.TypeInfo = EPTypeHelper.SingleEvent(inputEventType); if (EnumMethodEnum == EnumMethodEnum.FIRST) { return(new EnumEvalFirstOfPredicateEvents(first.BodyEvaluator, first.StreamCountIncoming)); } else { return(new EnumEvalLastOfPredicateEvents(first.BodyEvaluator, first.StreamCountIncoming)); } } base.TypeInfo = EPTypeHelper.SingleValue(collectionComponentType); if (EnumMethodEnum == EnumMethodEnum.FIRST) { return(new EnumEvalFirstOfPredicateScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } else { return(new EnumEvalLastOfPredicateScalar( first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0])); } }
protected override Func <ExprDotEvalParamLambda, EPType> InitAndSingleParamReturnType( EventType inputEventType, Type collectionComponentType) { return(lambda => { var returnType = lambda.BodyForge.EvaluationType.GetBoxedType(); return EPTypeHelper.SingleValue(returnType); }); }
public static ExprDotEnumerationSourceForProps GetPropertyEnumerationSource(string propertyName, int streamId, EventType streamType, bool allowEnumType, bool disablePropertyExpressionEventCollCache) { var propertyType = streamType.GetPropertyType(propertyName); var typeInfo = EPTypeHelper.SingleValue(propertyType); // assume scalar for now // no enumeration methods, no need to expose as an enumeration if (!allowEnumType) { return(new ExprDotEnumerationSourceForProps(null, typeInfo, streamId, null)); } var fragmentEventType = streamType.GetFragmentType(propertyName); var getter = streamType.GetGetter(propertyName); ExprEvaluatorEnumeration enumEvaluator = null; if (getter != null && fragmentEventType != null) { if (fragmentEventType.IsIndexed) { enumEvaluator = new PropertyExprEvaluatorEventCollection(propertyName, streamId, fragmentEventType.FragmentType, getter, disablePropertyExpressionEventCollCache); typeInfo = EPTypeHelper.CollectionOfEvents(fragmentEventType.FragmentType); } else { // we don't want native to require an eventbean instance enumEvaluator = new PropertyExprEvaluatorEventSingle(streamId, fragmentEventType.FragmentType, getter); typeInfo = EPTypeHelper.SingleEvent(fragmentEventType.FragmentType); } } else { var desc = EventTypeUtility.GetNestablePropertyDescriptor(streamType, propertyName); if (desc != null && desc.IsIndexed && !desc.RequiresIndex && desc.PropertyComponentType != null) { if (propertyType.IsGenericCollection()) { enumEvaluator = new PropertyExprEvaluatorScalarCollection(propertyName, streamId, getter, desc.PropertyComponentType); } else if (propertyType.IsImplementsInterface(typeof(System.Collections.IEnumerable))) { enumEvaluator = new PropertyExprEvaluatorScalarIterable(propertyName, streamId, getter, desc.PropertyComponentType); } else if (propertyType.IsArray) { enumEvaluator = new PropertyExprEvaluatorScalarArray(propertyName, streamId, getter, desc.PropertyComponentType); } else { throw new IllegalStateException("Property indicated indexed-type but failed to find proper collection adapter for use with enumeration methods"); } typeInfo = EPTypeHelper.CollectionOfSingleValue(desc.PropertyComponentType); } } var enumEvaluatorGivenEvent = (ExprEvaluatorEnumerationGivenEvent)enumEvaluator; return(new ExprDotEnumerationSourceForProps(enumEvaluator, typeInfo, streamId, enumEvaluatorGivenEvent)); }
protected override Func <ExprDotEvalParamLambda, EPType> InitAndSingleParamReturnType( EventType inputEventType, Type collectionComponentType) { return(lambda => { aggMethodFactory = GetAggregatorFactory(lambda.BodyForge.EvaluationType); var returnType = Boxing.GetBoxedType(aggMethodFactory.ValueType); return EPTypeHelper.SingleValue(returnType); }); }
public EnumForgeDesc MakeEnumForgeDesc( IList<ExprDotEvalParam> bodiesAndParameters, int streamCountIncoming, StatementCompileTimeServices services) { var body = bodiesAndParameters[0].BodyForge; var type = EPTypeHelper.SingleValue(typeof(bool?)); EnumForge forge = new EnumSequenceEqualForge(body, streamCountIncoming, _isScalar); return new EnumForgeDesc(type, forge); }
protected override EPType InitAndNoParamsReturnType( EventType inputEventType, Type collectionComponentType) { if (inputEventType != null) { return(EPTypeHelper.SingleEvent(inputEventType)); } return(EPTypeHelper.SingleValue(collectionComponentType)); }
protected override Func <ExprDotEvalParamLambda, EPType> InitAndSingleParamReturnType( EventType inputEventType, Type collectionComponentType) { if (inputEventType == null) { return(lambda => EPTypeHelper.SingleValue(collectionComponentType)); } return(lambda => EPTypeHelper.SingleEvent(inputEventType)); }
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()) { if (inputEventType != null) { TypeInfo = EPTypeHelper.SingleEvent(inputEventType); } else { TypeInfo = EPTypeHelper.SingleValue(collectionComponentType); } if (EnumMethodEnum == EnumMethodEnum.FIRST) { return new EnumFirstOfNoPredicateForge(numStreamsIncoming, TypeInfo); } else { return new EnumLastOfNoPredicateForge(numStreamsIncoming, TypeInfo); } } var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; if (inputEventType != null) { TypeInfo = EPTypeHelper.SingleEvent(inputEventType); if (EnumMethodEnum == EnumMethodEnum.FIRST) { return new EnumFirstOfPredicateEventsForge(first.BodyForge, first.StreamCountIncoming); } else { return new EnumLastOfPredicateEventsForge(first.BodyForge, first.StreamCountIncoming); } } TypeInfo = EPTypeHelper.SingleValue(collectionComponentType); if (EnumMethodEnum == EnumMethodEnum.FIRST) { return new EnumFirstOfPredicateScalarForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0], TypeInfo); } else { return new EnumLastOfPredicateScalarForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0], TypeInfo); } }
public EnumForgeDesc MakeEnumForgeDesc( IList <ExprDotEvalParam> bodiesAndParameters, int streamCountIncoming, StatementCompileTimeServices services) { var init = bodiesAndParameters[0].BodyForge; var compute = (ExprDotEvalParamLambda)bodiesAndParameters[1]; EnumAggregateScalar forge = new EnumAggregateScalar(streamCountIncoming, init, compute.BodyForge, _evalEventType, compute.GoesToNames.Count); var type = EPTypeHelper.SingleValue(init.EvaluationType.GetBoxedType()); return(new EnumForgeDesc(type, forge)); }
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()) { if (collectionComponentType.IsDecimal() || collectionComponentType.IsBigInteger()) { TypeInfo = EPTypeHelper.SingleValue(typeof(decimal?)); return new EnumAverageDecimalScalarForge( numStreamsIncoming, services.ImportServiceCompileTime.DefaultMathContext); } TypeInfo = EPTypeHelper.SingleValue(typeof(double?)); return new EnumAverageScalarForge(numStreamsIncoming); } var first = (ExprDotEvalParamLambda) bodiesAndParameters[0]; var returnType = first.BodyForge.EvaluationType; if (returnType.IsDecimal() || returnType.IsBigInteger()) { TypeInfo = EPTypeHelper.SingleValue(typeof(decimal?)); if (inputEventType == null) { return new EnumAverageDecimalScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0], services.ImportServiceCompileTime.DefaultMathContext); } return new EnumAverageDecimalEventsForge( first.BodyForge, first.StreamCountIncoming, services.ImportServiceCompileTime.DefaultMathContext); } TypeInfo = EPTypeHelper.SingleValue(typeof(double?)); if (inputEventType == null) { return new EnumAverageScalarLambdaForge( first.BodyForge, first.StreamCountIncoming, (ObjectArrayEventType) first.GoesToTypes[0]); } return new EnumAverageEventsForge(first.BodyForge, first.StreamCountIncoming); }