// -------------------------------------------------------------------------------- public static DateTime Round(this DateTime dt, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: { dt = dt.AddTicks(5000); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Millisecond, dt.Kind)); } case DateTimeFieldEnum.SECOND: { dt = dt.AddMilliseconds(500); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0, dt.Kind)); } case DateTimeFieldEnum.MINUTE: { dt = dt.AddSeconds(30); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, 0, 0, dt.Kind)); } case DateTimeFieldEnum.HOUR: { dt = dt.AddMinutes(30); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, 0, 0, 0, dt.Kind)); } case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: { dt = dt.Add(TimeSpan.FromSeconds(43200)); return(new DateTime(dt.Year, dt.Month, dt.Day, 0, 0, 0, 0, dt.Kind)); } case DateTimeFieldEnum.MONTH: { var stMonth = dt.Month; var stYear = dt.Year; var stDate = new DateTime(stYear, stMonth, 1, 0, 0, 0, 0, dt.Kind); var edMonth = stMonth == 12 ? 1 : stMonth + 1; var edYear = stMonth == 12 ? stYear + 1 : stYear; var edDate = new DateTime(edYear, edMonth, 1, 0, 0, 0, 0, dt.Kind); var ticksInHalfMonth = (edDate.Ticks - stDate.Ticks) / 2; dt = dt.AddTicks(ticksInHalfMonth); return(new DateTime(dt.Year, dt.Month, 1, 0, 0, 0, 0, dt.Kind)); } case DateTimeFieldEnum.YEAR: { var stYear = dt.Year; var stDate = new DateTime(stYear, 1, 1, 0, 0, 0, 0, dt.Kind); var edDate = new DateTime(stYear + 1, 1, 1, 0, 0, 0, 0, dt.Kind); var ticksInHalfYear = (edDate.Ticks - stDate.Ticks) / 2; dt = dt.AddTicks(ticksInHalfYear); return(new DateTime(dt.Year, 1, 1, 0, 0, 0, 0, dt.Kind)); } default: throw new NotSupportedException(); } }
/// <summary> /// Gets the actual maximum. /// </summary> /// <param name="dateTime">The date time.</param> /// <param name="field">The field.</param> /// <returns></returns> public static int GetActualMaximum(this DateTime dateTime, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(999); case DateTimeFieldEnum.SECOND: return(59); case DateTimeFieldEnum.MINUTE: return(59); case DateTimeFieldEnum.HOUR_OF_DAY: return(23); case DateTimeFieldEnum.DATE: case DateTimeFieldEnum.DAY_OF_MONTH: return(dateTime.GetWithMaximumDay().Day); case DateTimeFieldEnum.MONTH: return(dateTime.GetWithMaximumMonth().Month); case DateTimeFieldEnum.YEAR: return(DateTime.MaxValue.Year); default: throw new ArgumentException("invalid datetime"); } }
public ReformatGetFieldForge( DateTimeFieldEnum fieldNum, TimeAbacus timeAbacus) { this._fieldNum = fieldNum; this._timeAbacus = timeAbacus; }
// -------------------------------------------------------------------------------- public static ValueRange <int> Range( this DateTime dt, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(new ValueRange <int>(0, 999)); case DateTimeFieldEnum.SECOND: return(new ValueRange <int>(0, 59)); case DateTimeFieldEnum.MINUTE: return(new ValueRange <int>(0, 59)); case DateTimeFieldEnum.HOUR: return(new ValueRange <int>(0, 23)); case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: return(new ValueRange <int>(1, DateTime.DaysInMonth(dt.Year, dt.Month))); case DateTimeFieldEnum.MONTH: return(new ValueRange <int>(1, 12)); case DateTimeFieldEnum.YEAR: return(new ValueRange <int>( DateTime.MinValue.Year, DateTime.MaxValue.Year)); default: throw new NotSupportedException(); } }
public static int GetValueUsingFieldEnum( DateTimeEx dateTime, DateTimeFieldEnum fieldEnum) { switch (fieldEnum) { case DateTimeFieldEnum.YEAR: return dateTime.Year; case DateTimeFieldEnum.MONTH: return dateTime.Month; case DateTimeFieldEnum.DAY: return dateTime.Day; case DateTimeFieldEnum.HOUR: return dateTime.Hour; case DateTimeFieldEnum.MINUTE: return dateTime.Minute; case DateTimeFieldEnum.SECOND: return dateTime.Second; case DateTimeFieldEnum.MILLISEC: return dateTime.Millisecond; case DateTimeFieldEnum.WEEK: return dateTime.WeekOfYear; } throw new ArgumentException("unknown field", nameof(fieldEnum)); }
/// <summary> /// Gets the actual minimum. /// </summary> /// <param name="dateTime">The date time.</param> /// <param name="field">The field.</param> /// <returns></returns> public static int GetActualMinimum(this DateTimeOffset dateTime, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(0); case DateTimeFieldEnum.SECOND: return(0); case DateTimeFieldEnum.MINUTE: return(0); case DateTimeFieldEnum.HOUR_OF_DAY: return(0); case DateTimeFieldEnum.DATE: case DateTimeFieldEnum.DAY_OF_MONTH: return(1); case DateTimeFieldEnum.MONTH: return(1); case DateTimeFieldEnum.YEAR: return(DateTime.MinValue.Year); default: throw new ArgumentException("invalid datetime"); } }
public static DateTime With(this DateTime dt, DateTimeFieldEnum field, int value) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(WithMilli(dt, value)); case DateTimeFieldEnum.SECOND: return(WithSecond(dt, value)); case DateTimeFieldEnum.MINUTE: return(WithMinute(dt, value)); case DateTimeFieldEnum.HOUR: return(WithHour(dt, value)); case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: return(WithDay(dt, value)); case DateTimeFieldEnum.MONTH: return(WithMonth(dt, value)); case DateTimeFieldEnum.YEAR: return(WithYear(dt, value)); default: throw new NotSupportedException(); } }
/// <summary> /// Gets the field value. /// </summary> /// <param name="dateTime">The date time.</param> /// <param name="field">The field.</param> /// <returns></returns> public static int GetFieldValue(this DateTimeOffset dateTime, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(dateTime.Millisecond); case DateTimeFieldEnum.SECOND: return(dateTime.Second); case DateTimeFieldEnum.MINUTE: return(dateTime.Minute); case DateTimeFieldEnum.HOUR_OF_DAY: return(dateTime.Hour); case DateTimeFieldEnum.DATE: case DateTimeFieldEnum.DAY_OF_MONTH: return(dateTime.Day); case DateTimeFieldEnum.MONTH: return(dateTime.Month); case DateTimeFieldEnum.YEAR: return(dateTime.Year); default: throw new ArgumentException("invalid datetime"); } }
/// <summary> /// Adds using field to indicate which datetime field to add to. /// </summary> /// <param name="dateTime">The date time.</param> /// <param name="field">The field.</param> /// <param name="amount">The amount.</param> /// <returns></returns> public static DateTimeOffset AddUsingField(this DateTimeOffset dateTime, DateTimeFieldEnum field, int amount) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(dateTime.AddMilliseconds(amount)); case DateTimeFieldEnum.SECOND: return(dateTime.AddSeconds(amount)); case DateTimeFieldEnum.MINUTE: return(dateTime.AddMinutes(amount)); case DateTimeFieldEnum.HOUR_OF_DAY: return(dateTime.AddHours(amount)); case DateTimeFieldEnum.DATE: case DateTimeFieldEnum.DAY_OF_MONTH: return(dateTime.AddDays(amount)); case DateTimeFieldEnum.MONTH: return(dateTime.AddMonthsLikeJava(amount)); case DateTimeFieldEnum.YEAR: return(dateTime.AddYears(amount)); default: throw new ArgumentException("invalid datetime"); } }
public static int GetValueUsingFieldEnum( DateTimeOffset dateTime, DateTimeFieldEnum fieldEnum) { switch (fieldEnum) { case DateTimeFieldEnum.YEAR: return dateTime.Year; case DateTimeFieldEnum.MONTH: return dateTime.Month; case DateTimeFieldEnum.DAY: return dateTime.Day; case DateTimeFieldEnum.HOUR: return dateTime.Hour; case DateTimeFieldEnum.MINUTE: return dateTime.Minute; case DateTimeFieldEnum.SECOND: return dateTime.Second; case DateTimeFieldEnum.MILLISEC: return dateTime.Millisecond; case DateTimeFieldEnum.WEEK: return DateTimeMath.GetWeekOfYear(dateTime); } throw new ArgumentOutOfRangeException(nameof(fieldEnum), fieldEnum, "unknown field"); }
public CalendarForgeRound( DateTimeFieldEnum field, DateTimeMethodEnum method) { this.field = field; this.method = method; }
public CalendarSetForge( DateTimeFieldEnum field, ExprForge valueExpr) { this.field = field; this.valueExpr = valueExpr; }
public CalendarSetForgeOp( DateTimeFieldEnum field, ExprEvaluator valueExpr) { _field = field; _valueExpr = valueExpr; }
// -------------------------------------------------------------------------------- public static DateTimeOffset Truncate(this DateTimeOffset dto, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, dto.Offset)); case DateTimeFieldEnum.SECOND: return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, 0, dto.Offset)); case DateTimeFieldEnum.MINUTE: return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, 0, 0, dto.Offset)); case DateTimeFieldEnum.HOUR: return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, 0, 0, 0, dto.Offset)); case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, 0, 0, 0, 0, dto.Offset)); case DateTimeFieldEnum.MONTH: return(new DateTimeOffset(dto.Year, dto.Month, 1, 0, 0, 0, 0, dto.Offset)); case DateTimeFieldEnum.YEAR: return(new DateTimeOffset(dto.Year, 1, 1, 0, 0, 0, 0, dto.Offset)); default: throw new NotSupportedException(); } }
// -------------------------------------------------------------------------------- public static DateTime Ceiling(this DateTime dt, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: { dt = dt.AddTicks(9999); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Millisecond, dt.Kind)); } case DateTimeFieldEnum.SECOND: { dt = dt.AddMilliseconds(999); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, 0, dt.Kind)); } case DateTimeFieldEnum.MINUTE: { dt = dt.AddSeconds(59); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, 0, 0, dt.Kind)); } case DateTimeFieldEnum.HOUR: { dt = dt.AddMinutes(59); return(new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, 0, 0, 0, dt.Kind)); } case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: { var baseDt = new DateTime(dt.Year, dt.Month, dt.Day, 0, 0, 0, 0, dt.Kind); if (baseDt == dt) { return(baseDt); } return(baseDt.AddDays(1)); } case DateTimeFieldEnum.MONTH: { var baseDt = new DateTime(dt.Year, dt.Month, 1, 0, 0, 0, 0, dt.Kind); if (baseDt == dt) { return(baseDt); } return(baseDt.AddMonths(1)); } case DateTimeFieldEnum.YEAR: { var baseDt = new DateTime(dt.Year, 1, 1, 0, 0, 0, 0, dt.Kind); if (baseDt == dt) { return(baseDt); } return(baseDt.AddYears(1)); } default: throw new NotSupportedException(); } }
protected internal static CodegenExpression CodegenDateTimeOffsetDtxMinMax( CodegenExpression val, bool max, DateTimeFieldEnum field) { var fieldExpr = EnumValue(field); var valueRange = ExprDotMethod(val, "Range", fieldExpr); return ExprDotMethod(val, "With", fieldExpr, GetProperty(valueRange, max ? "Maximum" : "Minimum")); }
public static DateTimeEx Modify( DateTimeEx val, DateTimeFieldEnum field, int modType) { return(DateTimeEx.GetInstance( val.TimeZone, Modify(val.DateTime, field, modType, val.TimeZone))); }
public CalendarForge GetOp( DateTimeMethodEnum method, string methodNameUsed, IList<ExprNode> parameters, ExprForge[] forges) { if (method == DateTimeMethodEnum.WITHTIME) { return new CalendarWithTimeForge(forges[0], forges[1], forges[2], forges[3]); } if (method == DateTimeMethodEnum.WITHDATE) { return new CalendarWithDateForge(forges[0], forges[1], forges[2]); } if (method == DateTimeMethodEnum.PLUS || method == DateTimeMethodEnum.MINUS) { return new CalendarPlusMinusForge(forges[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) { DateTimeFieldEnum fieldNum = CalendarOpUtil.GetEnum(methodNameUsed, parameters[0]); if (method == DateTimeMethodEnum.WITHMIN) { return new CalendarWithMinForge(fieldNum); } if (method == DateTimeMethodEnum.ROUNDCEILING || method == DateTimeMethodEnum.ROUNDFLOOR || method == DateTimeMethodEnum.ROUNDHALF) { return new CalendarForgeRound(fieldNum, method); } if (method == DateTimeMethodEnum.SET) { return new CalendarSetForge(fieldNum, forges[1]); } return new CalendarWithMaxForge(fieldNum); } throw new IllegalStateException("Unrecognized calendar-op code '" + method + "'"); }
public static DateTimeOffset SetFieldValue( this DateTimeOffset dateTime, DateTimeFieldEnum field, int value) { switch (field) { case DateTimeFieldEnum.MILLISEC: return(DateTimeOffsetHelper.CreateDateTime( dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, value, dateTime.Offset)); case DateTimeFieldEnum.SECOND: return(DateTimeOffsetHelper.CreateDateTime( dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, value, dateTime.Millisecond, dateTime.Offset)); case DateTimeFieldEnum.MINUTE: return(DateTimeOffsetHelper.CreateDateTime( dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, value, dateTime.Second, dateTime.Millisecond, dateTime.Offset)); case DateTimeFieldEnum.HOUR_OF_DAY: return(DateTimeOffsetHelper.CreateDateTime( dateTime.Year, dateTime.Month, dateTime.Day, value, dateTime.Minute, dateTime.Second, dateTime.Millisecond, dateTime.Offset)); case DateTimeFieldEnum.DATE: case DateTimeFieldEnum.DAY_OF_MONTH: return(DateTimeOffsetHelper.CreateDateTime( dateTime.Year, dateTime.Month, value, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond, dateTime.Offset)); case DateTimeFieldEnum.MONTH: return(DateTimeOffsetHelper.CreateDateTime( dateTime.Year, value, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond, dateTime.Offset)); case DateTimeFieldEnum.YEAR: return(DateTimeOffsetHelper.CreateDateTime( value, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond, dateTime.Offset)); default: throw new ArgumentException("invalid datetime"); } }
public static DateTime Modify( DateTime val, DateTimeFieldEnum field, int modType) { if (val.Year > 280000000) { throw new ArithmeticException("DateTimeEx value too large for accurate calculations"); } if (field == DateTimeFieldEnum.MILLISEC) { return(val); } var time = val.UtcMillis(); var done = false; // truncate milliseconds var millisecs = val.Millisecond; if (MODIFY_TRUNCATE == modType || millisecs < 500) { time = time - millisecs; } if (field == DateTimeFieldEnum.SECOND) { done = true; } // truncate seconds var seconds = val.Second; if (!done && (MODIFY_TRUNCATE == modType || seconds < 30)) { time = time - seconds * 1000L; } if (field == DateTimeFieldEnum.MINUTE) { done = true; } // truncate minutes var minutes = val.Minute; if (!done && (MODIFY_TRUNCATE == modType || minutes < 30)) { time = time - minutes * 60000L; } // reset time if (val.UtcMillis() != time) { val = time.TimeFromMillis(); } // ----------------- Fix for LANG-59 ----------------------- END ---------------- var roundUp = false; for (var i = 0; i < Fields.Length; i++) { for (var j = 0; j < Fields[i].Length; j++) { if (Fields[i][j] == field) { //This is our field... we stop looping if (modType == MODIFY_CEILING || modType == MODIFY_ROUND && roundUp) { if (field == DateTimeFieldEnum.SEMI_MONTH) { //This is a special case that's hard to generalize //If the date is 1, we round up to 16, otherwise // we subtract 15 days and add 1 month if (val.Day == 1) { val = val.AddDays(15); } else { val = val.AddDays(-15).AddMonths(1); } // ----------------- Fix for LANG-440 ---------------------- START --------------- } else if (field == DateTimeFieldEnum.AM_PM) { // This is a special case // If the time is 0, we round up to 12, otherwise // we subtract 12 hours and add 1 day if (val.Hour == 0) { val = val.AddHours(12); } else { val = val.AddHours(-12).AddDays(1); } // ----------------- Fix for LANG-440 ---------------------- END --------------- } else { //We need at add one to this field since the // last number causes us to round up val = val.AddUsingField(Fields[i][0], 1); } } return(val); } } //We have various fields that are not easy roundings var offset = 0; var offsetSet = false; //These are special types of fields that require different rounding rules switch (field) { case DateTimeFieldEnum.SEMI_MONTH: if (Fields[i][0] == DateTimeFieldEnum.DATE) { //If we're going to drop the DATE field's value, // we want to do this our own way. //We need to subtrace 1 since the date has a minimum of 1 offset = val.Day - 1; //If we're above 15 days adjustment, that means we're in the // bottom half of the month and should stay accordingly. if (offset >= 15) { offset -= 15; } //Record whether we're in the top or bottom half of that range roundUp = offset > 7; offsetSet = true; } break; case DateTimeFieldEnum.AM_PM: if (Fields[i][0] == DateTimeFieldEnum.HOUR_OF_DAY) { //If we're going to drop the HOUR field's value, // we want to do this our own way. offset = val.Hour; if (offset >= 12) { offset -= 12; } roundUp = offset >= 6; offsetSet = true; } break; } if (!offsetSet) { var min = val.GetActualMinimum(Fields[i][0]); var max = val.GetActualMaximum(Fields[i][0]); //Calculate the offset from the minimum allowed value offset = val.GetFieldValue(Fields[i][0]) - min; //Set roundUp if this is more than half way between the minimum and maximum roundUp = offset > (max - min) / 2; } //We need to remove this field if (offset != 0) { val = val.SetFieldValue(Fields[i][0], val.GetFieldValue(Fields[i][0]) - offset); } } throw new ArgumentException("The field " + field + " is not supported"); }
public static int GetValueUsingFieldEnum( DateTime dateTime, DateTimeFieldEnum fieldEnum) { return GetValueUsingFieldEnum(DateTimeEx.UtcInstance(dateTime), fieldEnum); }
public CalendarWithMaxForge(DateTimeFieldEnum field) { _field = field; }