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