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));
}
