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