public EnumForgeDesc( EPType type, EnumForge forge) { Type = type; Forge = forge; }
public EnumForgeDesc MakeEnumForgeDesc( IList <ExprDotEvalParam> bodiesAndParameters, int streamCountIncoming, StatementCompileTimeServices services) { ExprDotEvalParamLambda first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; ExprDotEvalParamLambda second = (ExprDotEvalParamLambda)bodiesAndParameters[1]; EnumForge forge = function.Invoke(first, second, streamCountIncoming, returnType, services); return(new EnumForgeDesc(returnType, forge)); }
public EnumForgeDesc MakeEnumForgeDesc( IList <ExprDotEvalParam> bodiesAndParameters, int streamCountIncoming, StatementCompileTimeServices services) { ExprDotEvalParamLambda key = (ExprDotEvalParamLambda)bodiesAndParameters[0]; ExprDotEvalParamLambda value = (ExprDotEvalParamLambda)bodiesAndParameters[1]; EnumForge forge = function.Invoke(key, value, streamCountIncoming, typeKey, typeValue, numParams, returnType, services); return(new EnumForgeDesc(returnType, forge)); }
public EnumForgeDesc MakeEnumForgeDesc( IList <ExprDotEvalParam> bodiesAndParameters, int streamCountIncoming, StatementCompileTimeServices services) { if (bodiesAndParameters.IsEmpty()) { throw new UnsupportedOperationException(); } ExprDotEvalParamLambda first = (ExprDotEvalParamLambda)bodiesAndParameters[0]; EPType typeInfo = _returnType.Invoke(first); EnumForge forge = MakeForgeWithParam(first, typeInfo, services); return(new EnumForgeDesc(typeInfo, forge)); }
public EnumForgeDesc MakeEnumForgeDesc( IList<ExprDotEvalParam> bodiesAndParameters, int streamCountIncoming, StatementCompileTimeServices services) { var scalar = _type is ClassMultiValuedEPType; EnumForge forge = _enumMethod switch { EnumMethodEnum.UNION => new EnumUnionForge(streamCountIncoming, _enumSrc.Enumeration, scalar), EnumMethodEnum.INTERSECT => new EnumIntersectForge(streamCountIncoming, _enumSrc.Enumeration, scalar), EnumMethodEnum.EXCEPT => new EnumExceptForge(streamCountIncoming, _enumSrc.Enumeration, scalar), _ => throw new ArgumentException("Invalid enumeration method for this factory: " + _enumMethod) }; return new EnumForgeDesc(_type, forge); } }
public void Init( int? streamOfProviderIfApplicable, EnumMethodEnum enumMethodEnum, string enumMethodUsedName, EPType typeInfo, IList<ExprNode> parameters, ExprValidationContext validationContext) { var eventTypeColl = typeInfo.GetEventTypeMultiValued(); var eventTypeBean = typeInfo.GetEventTypeSingleValued(); var collectionComponentType = typeInfo.GetClassMultiValued(); this.enumMethodEnum = enumMethodEnum; this.enumMethodUsedName = enumMethodUsedName; streamCountIncoming = validationContext.StreamTypeService.EventTypes.Length; if (eventTypeColl == null && collectionComponentType == null && eventTypeBean == null) { throw new ExprValidationException( "Invalid input for built-in enumeration method '" + enumMethodUsedName + "', expecting collection of event-type or scalar values as input, received " + typeInfo.ToTypeDescriptive()); } // compile parameter abstract for validation against available footprints DotMethodFPProvided footprintProvided = DotMethodUtil.GetProvidedFootprint(parameters); // validate parameters DotMethodInputTypeMatcher inputTypeMatcher = new ProxyDotMethodInputTypeMatcher { ProcMatches = fp => { if (fp.Input == DotMethodFPInputEnum.EVENTCOLL && eventTypeBean == null && eventTypeColl == null) { return false; } if (fp.Input == DotMethodFPInputEnum.SCALAR_ANY && collectionComponentType == null) { return false; } return true; } }; DotMethodFP footprint = DotMethodUtil.ValidateParametersDetermineFootprint( enumMethodEnum.GetFootprints(), DotMethodTypeEnum.ENUM, enumMethodUsedName, footprintProvided, inputTypeMatcher); // validate input criteria met for this footprint if (footprint.Input != DotMethodFPInputEnum.ANY) { var message = "Invalid input for built-in enumeration method '" + enumMethodUsedName + "' and " + footprint.Parameters.Length + "-parameter footprint, expecting collection of "; var received = " as input, received " + EPTypeHelper.ToTypeDescriptive(typeInfo); if (footprint.Input == DotMethodFPInputEnum.EVENTCOLL && eventTypeColl == null) { throw new ExprValidationException(message + "events" + received); } if (footprint.Input.IsScalar() && collectionComponentType == null) { throw new ExprValidationException(message + "values (typically scalar values)" + received); } if (footprint.Input == DotMethodFPInputEnum.SCALAR_NUMERIC && !collectionComponentType.IsNumeric()) { throw new ExprValidationException(message + "numeric values" + received); } } // manage context of this lambda-expression in regards to outer lambda-expression that may call this one. var enumCallStackHelper = validationContext.EnumMethodCallStackHelper; enumCallStackHelper.PushStack(this); IList<ExprDotEvalParam> bodiesAndParameters = new List<ExprDotEvalParam>(); var count = 0; var inputEventType = eventTypeBean == null ? eventTypeColl : eventTypeBean; foreach (var node in parameters) { var bodyAndParameter = GetBodyAndParameter( enumMethodUsedName, count++, node, inputEventType, collectionComponentType, validationContext, bodiesAndParameters, footprint); bodiesAndParameters.Add(bodyAndParameter); } enumForge = GetEnumForge( validationContext.StreamTypeService, enumMethodUsedName, bodiesAndParameters, inputEventType, // TBD: collectionType, may not be applicable collectionComponentType, streamCountIncoming, validationContext.IsDisablePropertyExpressionEventCollCache, validationContext.StatementRawInfo, validationContext.StatementCompileTimeService); enumEvalNumRequiredEvents = enumForge.StreamNumSize; // determine the stream ids of event properties asked for in the evaluator(s) var streamsRequired = new HashSet<int>(); var visitor = new ExprNodeIdentifierCollectVisitor(); foreach (var desc in bodiesAndParameters) { desc.Body.Accept(visitor); foreach (var ident in visitor.ExprProperties) { streamsRequired.Add(ident.StreamId); } } if (streamOfProviderIfApplicable != null) { streamsRequired.Add(streamOfProviderIfApplicable.Value); } // We turn on caching if the stack is not empty (we are an inner lambda) and the dependency does not include the stream. var isInner = !enumCallStackHelper.PopLambda(); if (isInner) { // If none of the properties that the current lambda uses comes from the ultimate parent(s) or subsequent streams, then cache. Deque<ExpressionResultCacheStackEntry> parents = enumCallStackHelper.GetStack(); var found = false; foreach (var req in streamsRequired) { var first = (ExprDotForgeEnumMethodBase) parents.First; var parentIncoming = first.streamCountIncoming - 1; var selfAdded = streamCountIncoming; // the one we use ourselfs if (req > parentIncoming && req < selfAdded) { found = true; } } cache = !found; } }