public FilterExprAnalyzerAffector GetFilterDesc( EventType[] typesPerStream, DatetimeMethodEnum currentMethod, IList <ExprNode> currentParameters, ExprDotNodeFilterAnalyzerInput inputDesc) { if (_includeLow == null || _includeHigh == null) { return(null); } int targetStreamNum; string targetProperty; if (inputDesc is ExprDotNodeFilterAnalyzerInputStream) { var targetStream = (ExprDotNodeFilterAnalyzerInputStream)inputDesc; targetStreamNum = targetStream.StreamNum; var targetType = typesPerStream[targetStreamNum]; targetProperty = targetType.StartTimestampPropertyName; } else if (inputDesc is ExprDotNodeFilterAnalyzerInputProp) { var targetStream = (ExprDotNodeFilterAnalyzerInputProp)inputDesc; targetStreamNum = targetStream.StreamNum; targetProperty = targetStream.PropertyName; } else { return(null); } return(new FilterExprAnalyzerDTBetweenAffector( typesPerStream, targetStreamNum, targetProperty, _start, _end, _includeLow.Value, _includeHigh.Value)); }
public ExprDotNodeFilterAnalyzerDesc GetFilterDesc(EventType[] typesPerStream, DatetimeMethodEnum currentMethod, ICollection <ExprNode> currentParameters, ExprDotNodeFilterAnalyzerInput inputDesc) { if (_includeLow == null || _includeHigh == null) { return(null); } int targetStreamNum; String targetProperty; if (inputDesc is ExprDotNodeFilterAnalyzerInputStream) { var targetStream = (ExprDotNodeFilterAnalyzerInputStream)inputDesc; targetStreamNum = targetStream.StreamNum; EventType targetType = typesPerStream[targetStreamNum]; targetProperty = targetType.StartTimestampPropertyName; } else if (inputDesc is ExprDotNodeFilterAnalyzerInputProp) { var targetStream = (ExprDotNodeFilterAnalyzerInputProp)inputDesc; targetStreamNum = targetStream.StreamNum; targetProperty = targetStream.PropertyName; } else { return(null); } return(new ExprDotNodeFilterAnalyzerDTBetweenDesc(typesPerStream, targetStreamNum, targetProperty, _start, _end, _includeLow.GetValueOrDefault(), _includeHigh.GetValueOrDefault())); }
public ExprDotNodeFilterAnalyzerDesc GetFilterDesc(EventType[] typesPerStream, DatetimeMethodEnum currentMethod, ICollection <ExprNode> currentParameters, ExprDotNodeFilterAnalyzerInput inputDesc) { return(null); }
public ReformatOp GetOp(TimeZoneInfo timeZone, DatetimeMethodEnum method, String methodNameUsed, IList <ExprNode> parameters) { switch (method) { case DatetimeMethodEnum.GET: return(new ReformatOpGetField(CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]), timeZone)); case DatetimeMethodEnum.FORMAT: return(FormatString); case DatetimeMethodEnum.TOMILLISEC: return(ToMsec); case DatetimeMethodEnum.TODATE: return(new ReformatOpToDateTime(timeZone)); case DatetimeMethodEnum.TOCALENDAR: return(new ReformatOpToDateTime(timeZone)); case DatetimeMethodEnum.GETDAYOFMONTH: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.DayOfMonth, typeof(int), timeZone)); case DatetimeMethodEnum.GETMINUTEOFHOUR: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.MinuteOfHour, typeof(int), timeZone)); case DatetimeMethodEnum.GETMONTHOFYEAR: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.MonthOfYear, typeof(int), timeZone)); case DatetimeMethodEnum.GETDAYOFWEEK: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.DayOfWeek, typeof(DayOfWeek), timeZone)); case DatetimeMethodEnum.GETDAYOFYEAR: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.DayOfYear, typeof(int), timeZone)); case DatetimeMethodEnum.GETHOUROFDAY: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.HourOfDay, typeof(int), timeZone)); case DatetimeMethodEnum.GETMILLISOFSECOND: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.MillisOfSecond, typeof(int), timeZone)); case DatetimeMethodEnum.GETSECONDOFMINUTE: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.SecondOfMinute, typeof(int), timeZone)); case DatetimeMethodEnum.GETWEEKYEAR: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.Weekyear, typeof(int), timeZone)); case DatetimeMethodEnum.GETYEAR: return(new ReformatOpDateTimeEval(DateTimeEvalStatics.Year, typeof(int), timeZone)); case DatetimeMethodEnum.BETWEEN: if (ExprNodeUtility.IsAllConstants(parameters)) { return(new ReformatOpBetweenConstantParams(parameters)); } return(new ReformatOpBetweenNonConstantParams(parameters)); } throw new IllegalStateException("Unrecognized date-time method code '" + method + "'"); }
public FilterExprAnalyzerAffector GetFilterDesc( EventType[] typesPerStream, DatetimeMethodEnum currentMethod, IList <ExprNode> currentParameters, ExprDotNodeFilterAnalyzerInput inputDesc) { return(null); }
public IntervalOp GetOp( StreamTypeService streamTypeService, DatetimeMethodEnum method, string methodNameUsed, IList <ExprNode> parameters, TimeZoneInfo timeZone, TimeAbacus timeAbacus) { return(new IntervalOpImpl(method, methodNameUsed, streamTypeService, parameters, timeZone, timeAbacus)); }
public static DotMethodFP[] Footprints(this DatetimeMethodEnum datetimeMethodEnum) { var metaData = MetaData(datetimeMethodEnum); if (metaData != null) { return(metaData.Footprints); } throw new ArgumentException(); }
public FilterExprAnalyzerDTIntervalAffector(DatetimeMethodEnum currentMethod, EventType[] typesPerStream, int targetStreamNum, String targetStartProp, String targetEndProp, int?parameterStreamNum, String parameterStartProp, String parameterEndProp) { _currentMethod = currentMethod; _typesPerStream = typesPerStream; _targetStreamNum = targetStreamNum; _targetStartProp = targetStartProp; _targetEndProp = targetEndProp; _parameterStreamNum = parameterStreamNum; _parameterStartProp = parameterStartProp; _parameterEndProp = parameterEndProp; }
/// <summary> /// Obtain information used by filter analyzer to handle this dot-method invocation as part of query planning/indexing. /// </summary> /// <param name="typesPerStream">The types per stream.</param> /// <param name="currentMethod">The current method.</param> /// <param name="currentParameters">The current parameters.</param> /// <param name="inputDesc">The input desc.</param> /// <returns></returns> public FilterExprAnalyzerDTIntervalAffector GetFilterDesc( EventType[] typesPerStream, DatetimeMethodEnum currentMethod, IList <ExprNode> currentParameters, ExprDotNodeFilterAnalyzerInput inputDesc) { // with intervals is not currently query planned if (currentParameters.Count > 1) { return(null); } // Get input (target) int targetStreamNum; String targetPropertyStart; String targetPropertyEnd; if (inputDesc is ExprDotNodeFilterAnalyzerInputStream) { var targetStream = (ExprDotNodeFilterAnalyzerInputStream)inputDesc; targetStreamNum = targetStream.StreamNum; EventType targetType = typesPerStream[targetStreamNum]; targetPropertyStart = targetType.StartTimestampPropertyName; targetPropertyEnd = targetType.EndTimestampPropertyName ?? targetPropertyStart; } else if (inputDesc is ExprDotNodeFilterAnalyzerInputProp) { var targetStream = (ExprDotNodeFilterAnalyzerInputProp)inputDesc; targetStreamNum = targetStream.StreamNum; targetPropertyStart = targetStream.PropertyName; targetPropertyEnd = targetStream.PropertyName; } else { return(null); } // check parameter info if (_parameterPropertyStart == null) { return(null); } return(new FilterExprAnalyzerDTIntervalAffector(currentMethod, typesPerStream, targetStreamNum, targetPropertyStart, targetPropertyEnd, _parameterStreamNum, _parameterPropertyStart, _parameterPropertyEnd)); }
public CalendarOpRound(CalendarFieldEnum fieldName, DatetimeMethodEnum method) { _fieldName = fieldName; if (method == DatetimeMethodEnum.ROUNDCEILING) { _code = ApacheCommonsDateUtils.MODIFY_CEILING; } else if (method == DatetimeMethodEnum.ROUNDFLOOR) { _code = ApacheCommonsDateUtils.MODIFY_TRUNCATE; } else if (method == DatetimeMethodEnum.ROUNDHALF) { _code = ApacheCommonsDateUtils.MODIFY_ROUND; } else { throw new ArgumentException("Unrecognized method '" + method + "'"); } }
public CalendarOp GetOp(DatetimeMethodEnum method, String methodNameUsed, IList <ExprNode> parameters, ExprEvaluator[] evaluators) { if (method == DatetimeMethodEnum.WITHTIME) { return(new CalendarOpWithTime(evaluators[0], evaluators[1], evaluators[2], evaluators[3])); } if (method == DatetimeMethodEnum.WITHDATE) { return(new CalendarOpWithDate(evaluators[0], evaluators[1], evaluators[2])); } if (method == DatetimeMethodEnum.PLUS || method == DatetimeMethodEnum.MINUS) { return(new CalendarOpPlusMinus(evaluators[0], method == DatetimeMethodEnum.MINUS ? -1 : 1)); } if (method == DatetimeMethodEnum.WITHMAX || method == DatetimeMethodEnum.WITHMIN || method == DatetimeMethodEnum.ROUNDCEILING || method == DatetimeMethodEnum.ROUNDFLOOR || method == DatetimeMethodEnum.ROUNDHALF || method == DatetimeMethodEnum.SET) { CalendarFieldEnum fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]); if (method == DatetimeMethodEnum.WITHMIN) { return(new CalendarOpWithMin(fieldNum)); } if (method == DatetimeMethodEnum.ROUNDCEILING || method == DatetimeMethodEnum.ROUNDFLOOR || method == DatetimeMethodEnum.ROUNDHALF) { return(new CalendarOpRound(fieldNum, method)); } if (method == DatetimeMethodEnum.SET) { return(new CalendarOpSet(fieldNum, evaluators[1])); } return(new CalendarOpWithMax(fieldNum)); } throw new IllegalStateException("Unrecognized calendar-op code '" + method + "'"); }
public static DatetimeMethodEnumMetaData MetaData(this DatetimeMethodEnum datetimeMethodEnum) { return(MetaDataTable.Get(datetimeMethodEnum)); }
public IntervalOp GetOp(StreamTypeService streamTypeService, DatetimeMethodEnum method, String methodNameUsed, IList <ExprNode> parameters, ExprEvaluator[] evaluators) { return(new IntervalOpImpl(method, methodNameUsed, streamTypeService, parameters)); }
public IntervalOpImpl(DatetimeMethodEnum method, String methodNameUse, StreamTypeService streamTypeService, IList <ExprNode> expressions) { ExprEvaluator evaluatorEndTimestamp = null; Type timestampType; if (expressions[0] is ExprStreamUnderlyingNode) { var und = (ExprStreamUnderlyingNode)expressions[0]; _parameterStreamNum = und.StreamId; EventType type = streamTypeService.EventTypes[_parameterStreamNum]; _parameterPropertyStart = type.StartTimestampPropertyName; if (_parameterPropertyStart == null) { throw new ExprValidationException("For date-time method '" + methodNameUse + "' the first parameter is event type '" + type.Name + "', however no timestamp property has been defined for this event type"); } timestampType = type.GetPropertyType(_parameterPropertyStart); EventPropertyGetter getter = type.GetGetter(_parameterPropertyStart); _evaluatorTimestamp = new ExprEvaluatorStreamLongProp(_parameterStreamNum, getter); if (type.EndTimestampPropertyName != null) { _parameterPropertyEnd = type.EndTimestampPropertyName; EventPropertyGetter getterEndTimestamp = type.GetGetter(type.EndTimestampPropertyName); evaluatorEndTimestamp = new ExprEvaluatorStreamLongProp(_parameterStreamNum, getterEndTimestamp); } else { _parameterPropertyEnd = _parameterPropertyStart; } } else { _evaluatorTimestamp = expressions[0].ExprEvaluator; timestampType = _evaluatorTimestamp.ReturnType; String unresolvedPropertyName = null; if (expressions[0] is ExprIdentNode) { var identNode = (ExprIdentNode)expressions[0]; _parameterStreamNum = identNode.StreamId; _parameterPropertyStart = identNode.ResolvedPropertyName; _parameterPropertyEnd = _parameterPropertyStart; unresolvedPropertyName = identNode.UnresolvedPropertyName; } if (!_evaluatorTimestamp.ReturnType.IsDateTime()) { // ident node may represent a fragment if (unresolvedPropertyName != null) { var propertyDesc = ExprIdentNodeUtil.GetTypeFromStream( streamTypeService, unresolvedPropertyName, false, true); if (propertyDesc.First.FragmentEventType != null) { EventType type = propertyDesc.First.FragmentEventType.FragmentType; _parameterPropertyStart = type.StartTimestampPropertyName; if (_parameterPropertyStart == null) { throw new ExprValidationException("For date-time method '" + methodNameUse + "' the first parameter is event type '" + type.Name + "', however no timestamp property has been defined for this event type"); } timestampType = type.GetPropertyType(_parameterPropertyStart); EventPropertyGetter getterFragment = streamTypeService.EventTypes[_parameterStreamNum].GetGetter(unresolvedPropertyName); EventPropertyGetter getterStartTimestamp = type.GetGetter(_parameterPropertyStart); _evaluatorTimestamp = new ExprEvaluatorStreamLongPropFragment(_parameterStreamNum, getterFragment, getterStartTimestamp); if (type.EndTimestampPropertyName != null) { _parameterPropertyEnd = type.EndTimestampPropertyName; EventPropertyGetter getterEndTimestamp = type.GetGetter(type.EndTimestampPropertyName); evaluatorEndTimestamp = new ExprEvaluatorStreamLongPropFragment(_parameterStreamNum, getterFragment, getterEndTimestamp); } else { _parameterPropertyEnd = _parameterPropertyStart; } } } else { throw new ExprValidationException("For date-time method '" + methodNameUse + "' the first parameter expression returns '" + _evaluatorTimestamp.ReturnType.FullName + "', however requires a DateTime or Long-type return value or event (with timestamp)"); } } } IntervalComputer intervalComputer = IntervalComputerFactory.Make(method, expressions); // evaluation without end timestamp var timestampTypeBoxed = timestampType != null?timestampType.GetBoxedType() : timestampType; if (evaluatorEndTimestamp == null) { if (timestampTypeBoxed == typeof(DateTime?) || timestampTypeBoxed == typeof(DateTimeOffset?)) { _intervalOpEval = new IntervalOpEvalCal(intervalComputer); } else if (timestampTypeBoxed == typeof(long?)) { _intervalOpEval = new IntervalOpEvalLong(intervalComputer); } else { throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'"); } } else { if (timestampTypeBoxed == typeof(DateTime?) || timestampTypeBoxed == typeof(DateTimeOffset?)) { _intervalOpEval = new IntervalOpEvalCalWithEnd(intervalComputer, evaluatorEndTimestamp); } else if (timestampTypeBoxed == typeof(long?)) { _intervalOpEval = new IntervalOpEvalLongWithEnd(intervalComputer, evaluatorEndTimestamp); } else { throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'"); } } }
public static IntervalComputer Make(DatetimeMethodEnum method, IList <ExprNode> expressions, TimeAbacus timeAbacus) { var parameters = GetParameters(expressions, timeAbacus); if (method == DatetimeMethodEnum.BEFORE) { if (parameters.Length == 0) { return(new IntervalComputerBeforeNoParam()); } var pair = IntervalStartEndParameterPair.FromParamsWithLongMaxEnd(parameters); if (pair.IsConstant) { return(new IntervalComputerConstantBefore(pair)); } return(new IntervalComputerBeforeWithDeltaExpr(pair)); } else if (method == DatetimeMethodEnum.AFTER) { if (parameters.Length == 0) { return(new IntervalComputerAfterNoParam()); } var pair = IntervalStartEndParameterPair.FromParamsWithLongMaxEnd(parameters); if (pair.IsConstant) { return(new IntervalComputerConstantAfter(pair)); } return(new IntervalComputerAfterWithDeltaExpr(pair)); } else if (method == DatetimeMethodEnum.COINCIDES) { if (parameters.Length == 0) { return(new IntervalComputerCoincidesNoParam()); } var pair = IntervalStartEndParameterPair.FromParamsWithSameEnd(parameters); if (pair.IsConstant) { return(new IntervalComputerConstantCoincides(pair)); } return(new IntervalComputerCoincidesWithDeltaExpr(pair)); } else if (method == DatetimeMethodEnum.DURING || method == DatetimeMethodEnum.INCLUDES) { if (parameters.Length == 0) { if (method == DatetimeMethodEnum.DURING) { return(new IntervalComputerDuringNoParam()); } return(new IntervalComputerIncludesNoParam()); } var pair = IntervalStartEndParameterPair.FromParamsWithSameEnd(parameters); if (parameters.Length == 1) { return(new IntervalComputerDuringAndIncludesThreshold( method == DatetimeMethodEnum.DURING, pair.Start.Evaluator)); } if (parameters.Length == 2) { return(new IntervalComputerDuringAndIncludesMinMax( method == DatetimeMethodEnum.DURING, pair.Start.Evaluator, pair.End.Evaluator)); } return(new IntervalComputerDuringMinMaxStartEnd( method == DatetimeMethodEnum.DURING, GetEvaluators(expressions, timeAbacus))); } else if (method == DatetimeMethodEnum.FINISHES) { if (parameters.Length == 0) { return(new IntervalComputerFinishesNoParam()); } ValidateConstantThreshold("finishes", parameters[0]); return(new IntervalComputerFinishesThreshold(parameters[0].Evaluator)); } else if (method == DatetimeMethodEnum.FINISHEDBY) { if (parameters.Length == 0) { return(new IntervalComputerFinishedByNoParam()); } ValidateConstantThreshold("finishedby", parameters[0]); return(new IntervalComputerFinishedByThreshold(parameters[0].Evaluator)); } else if (method == DatetimeMethodEnum.MEETS) { if (parameters.Length == 0) { return(new IntervalComputerMeetsNoParam()); } ValidateConstantThreshold("meets", parameters[0]); return(new IntervalComputerMeetsThreshold(parameters[0].Evaluator)); } else if (method == DatetimeMethodEnum.METBY) { if (parameters.Length == 0) { return(new IntervalComputerMetByNoParam()); } ValidateConstantThreshold("metBy", parameters[0]); return(new IntervalComputerMetByThreshold(parameters[0].Evaluator)); } else if (method == DatetimeMethodEnum.OVERLAPS || method == DatetimeMethodEnum.OVERLAPPEDBY) { if (parameters.Length == 0) { if (method == DatetimeMethodEnum.OVERLAPS) { return(new IntervalComputerOverlapsNoParam()); } return(new IntervalComputerOverlappedByNoParam()); } if (parameters.Length == 1) { return(new IntervalComputerOverlapsAndByThreshold( method == DatetimeMethodEnum.OVERLAPS, parameters[0].Evaluator)); } return(new IntervalComputerOverlapsAndByMinMax( method == DatetimeMethodEnum.OVERLAPS, parameters[0].Evaluator, parameters[1].Evaluator)); } else if (method == DatetimeMethodEnum.STARTS) { if (parameters.Length == 0) { return(new IntervalComputerStartsNoParam()); } ValidateConstantThreshold("starts", parameters[0]); return(new IntervalComputerStartsThreshold(parameters[0].Evaluator)); } else if (method == DatetimeMethodEnum.STARTEDBY) { if (parameters.Length == 0) { return(new IntervalComputerStartedByNoParam()); } ValidateConstantThreshold("startedBy", parameters[0]); return(new IntervalComputerStartedByThreshold(parameters[0].Evaluator)); } throw new ArgumentException("Unknown datetime method '" + method + "'"); }
public static ExprDotEvalDTMethodDesc ValidateMake( StreamTypeService streamTypeService, Deque <ExprChainedSpec> chainSpecStack, DatetimeMethodEnum dtMethod, String dtMethodName, EPType inputType, IList <ExprNode> parameters, ExprDotNodeFilterAnalyzerInput inputDesc, TimeZoneInfo timeZone) { // verify input String message = "Date-time enumeration method '" + dtMethodName + "' requires either a DateTime or long value as input or events of an event type that declares a timestamp property"; if (inputType is EventEPType) { if (((EventEPType)inputType).EventType.StartTimestampPropertyName == null) { throw new ExprValidationException(message); } } else { if (!(inputType is ClassEPType || inputType is NullEPType)) { throw new ExprValidationException(message + " but received " + EPTypeHelper.ToTypeDescriptive(inputType)); } if (inputType is ClassEPType) { ClassEPType classEPType = (ClassEPType)inputType; if (!TypeHelper.IsDateTime(classEPType.Clazz)) { throw new ExprValidationException( message + " but received " + classEPType.Clazz.GetTypeNameFullyQualPretty()); } } } IList <CalendarOp> calendarOps = new List <CalendarOp>(); ReformatOp reformatOp = null; IntervalOp intervalOp = null; DatetimeMethodEnum currentMethod = dtMethod; IList <ExprNode> currentParameters = parameters; String currentMethodName = dtMethodName; // drain all calendar ops ExprDotNodeFilterAnalyzerDesc filterAnalyzerDesc = null; while (true) { // handle the first one only if its a calendar op var evaluators = GetEvaluators(currentParameters); var opFactory = currentMethod.MetaData().OpFactory; // compile parameter abstract for validation against available footprints var footprintProvided = DotMethodUtil.GetProvidedFootprint(currentParameters); // validate parameters DotMethodUtil.ValidateParametersDetermineFootprint( currentMethod.Footprints(), DotMethodTypeEnum.DATETIME, currentMethodName, footprintProvided, DotMethodInputTypeMatcherImpl.DEFAULT_ALL); if (opFactory is CalendarOpFactory) { CalendarOp calendarOp = ((CalendarOpFactory)opFactory).GetOp(currentMethod, currentMethodName, currentParameters, evaluators); calendarOps.Add(calendarOp); } else if (opFactory is ReformatOpFactory) { reformatOp = ((ReformatOpFactory)opFactory).GetOp(timeZone, currentMethod, currentMethodName, currentParameters); // compile filter analyzer information if there are no calendar ops in the chain if (calendarOps.IsEmpty()) { filterAnalyzerDesc = reformatOp.GetFilterDesc(streamTypeService.EventTypes, currentMethod, currentParameters, inputDesc); } else { filterAnalyzerDesc = null; } } else if (opFactory is IntervalOpFactory) { intervalOp = ((IntervalOpFactory)opFactory).GetOp(streamTypeService, currentMethod, currentMethodName, currentParameters, evaluators); // compile filter analyzer information if there are no calendar ops in the chain if (calendarOps.IsEmpty()) { filterAnalyzerDesc = intervalOp.GetFilterDesc(streamTypeService.EventTypes, currentMethod, currentParameters, inputDesc); } else { filterAnalyzerDesc = null; } } else { throw new IllegalStateException("Invalid op factory class " + opFactory); } // see if there is more if (chainSpecStack.IsEmpty() || !DatetimeMethodEnumExtensions.IsDateTimeMethod(chainSpecStack.First.Name)) { break; } // pull next var next = chainSpecStack.RemoveFirst(); currentMethod = DatetimeMethodEnumExtensions.FromName(next.Name); currentParameters = next.Parameters; currentMethodName = next.Name; if ((reformatOp != null || intervalOp != null)) { throw new ExprValidationException("Invalid input for date-time method '" + next.Name + "'"); } } ExprDotEval dotEval; EPType returnType; dotEval = new ExprDotEvalDT(calendarOps, timeZone, reformatOp, intervalOp, EPTypeHelper.GetClassSingleValued(inputType), EPTypeHelper.GetEventTypeSingleValued(inputType)); returnType = dotEval.TypeInfo; return(new ExprDotEvalDTMethodDesc(dotEval, returnType, filterAnalyzerDesc)); }
public ReformatOp GetOp( TimeZoneInfo timeZone, TimeAbacus timeAbacus, DatetimeMethodEnum method, string methodNameUsed, IList <ExprNode> parameters) { if (method == DatetimeMethodEnum.GET) { CalendarFieldEnum fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]); return(new ReformatOpGetField(fieldNum, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.FORMAT) { return(FORMAT_STRING); } if (method == DatetimeMethodEnum.TOCALENDAR) { return(new ReformatOpToCalendar(timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.TOMILLISEC) { return(new ReformatOpToMillisec(timeZone)); } if (method == DatetimeMethodEnum.TODATE) { return(new ReformatOpToDateTimeOffset(timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETDAYOFMONTH) { return(new ReformatOpEval <int>(CalendarEvalStatics.DAY_OF_MONTH, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETMINUTEOFHOUR) { return(new ReformatOpEval <int>(CalendarEvalStatics.MINUTE_OF_HOUR, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETMONTHOFYEAR) { return(new ReformatOpEval <int>(CalendarEvalStatics.MONTH_OF_YEAR, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETDAYOFWEEK) { return(new ReformatOpEval <DayOfWeek>(CalendarEvalStatics.DAY_OF_WEEK, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETDAYOFYEAR) { return(new ReformatOpEval <int>(CalendarEvalStatics.DAY_OF_YEAR, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETERA) { return(new ReformatOpEval <int>(CalendarEvalStatics.ERA, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETHOUROFDAY) { return(new ReformatOpEval <int>(CalendarEvalStatics.HOUR_OF_DAY, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETMILLISOFSECOND) { return(new ReformatOpEval <int>(CalendarEvalStatics.MILLIS_OF_SECOND, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETSECONDOFMINUTE) { return(new ReformatOpEval <int>(CalendarEvalStatics.SECOND_OF_MINUTE, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETWEEKYEAR) { return(new ReformatOpEval <int>(CalendarEvalStatics.WEEKYEAR, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.GETYEAR) { return(new ReformatOpEval <int>(CalendarEvalStatics.YEAR, timeZone, timeAbacus)); } if (method == DatetimeMethodEnum.BETWEEN) { if (ExprNodeUtility.IsAllConstants(parameters)) { return(new ReformatOpBetweenConstantParams(parameters, timeZone)); } return(new ReformatOpBetweenNonConstantParams(parameters, timeZone)); } throw new IllegalStateException("Unrecognized date-time method code '" + method + "'"); }