Java Code Examples for com.ibm.icu.util.Calendar#SUNDAY

/**
 * Formats a relative date without a quantity.
 * @param direction NEXT, LAST, THIS, etc.
 * @param unit e.g SATURDAY, DAY, MONTH
 * @return the formatted string. If direction has a value that is documented as not being
 *  fully supported in every locale (for example NEXT_2 or LAST_2) then this function may
 *  return null to signal that no formatted string is available.
 * @throws IllegalArgumentException if the direction is incompatible with
 * unit this can occur with NOW which can only take PLAIN.
 * @stable ICU 53
 */
public String format(Direction direction, AbsoluteUnit unit) {
    if (unit == AbsoluteUnit.NOW && direction != Direction.PLAIN) {
        throw new IllegalArgumentException("NOW can only accept direction PLAIN.");
    }
    String result;
    // Get plain day of week names from DateFormatSymbols.
    if ((direction == Direction.PLAIN) &&  (AbsoluteUnit.SUNDAY.ordinal() <= unit.ordinal() &&
            unit.ordinal() <= AbsoluteUnit.SATURDAY.ordinal())) {
        // Convert from AbsoluteUnit days to Calendar class indexing.
        int dateSymbolsDayOrdinal = (unit.ordinal() - AbsoluteUnit.SUNDAY.ordinal()) + Calendar.SUNDAY;
        String[] dayNames =
                dateFormatSymbols.getWeekdays(DateFormatSymbols.STANDALONE,
                styleToDateFormatSymbolsWidth[style.ordinal()]);
        result = dayNames[dateSymbolsDayOrdinal];
    } else {
        // Not PLAIN, or not a weekday.
        result = getAbsoluteUnitString(style, unit, direction);
    }
    return result != null ? adjustForContext(result) : null;
}
 

@Override
public void visit(TemporalExpressions.DayOfWeekRange expr) {
    int startDay = expr.getStartDay();
    int endDay = expr.getEndDay();
    WeekDayList dayList = new WeekDayList();
    dayList.add(dayOfWeekArray[startDay - 1]);
    while (startDay != endDay) {
        startDay++;
        if (startDay > Calendar.SATURDAY) {
            startDay = Calendar.SUNDAY;
        }
        dayList.add(dayOfWeekArray[startDay - 1]);
    }
    Recur recur = new Recur(Recur.DAILY, 0);
    recur.getDayList().addAll(dayList);
    this.state.addRecur(recur);
}
 

/**
 * @param dayOfWeek An integer in the range of <code>Calendar.SUNDAY</code>
 * to <code>Calendar.SATURDAY</code>
 * @param occurrence An integer in the range of -5 to 5, excluding zero
 */
public DayInMonth(int dayOfWeek, int occurrence) {
    if (dayOfWeek < Calendar.SUNDAY || dayOfWeek > Calendar.SATURDAY) {
        throw new IllegalArgumentException("Invalid day argument");
    }
    if (occurrence < -5 || occurrence == 0 || occurrence > 5) {
        throw new IllegalArgumentException("Invalid occurrence argument");
    }
    this.dayOfWeek = dayOfWeek;
    this.occurrence = occurrence;
    int result = occurrence;
    if (result < 0) {
        // Make negative values a higher sequence
        // Example: Last Monday should come after first Monday
        result += 11;
    }
    this.sequence = SEQUENCE_DAY_IN_MONTH + (result * 10) + dayOfWeek;
    if (Debug.verboseOn()) {
        Debug.logVerbose("Created " + this, module);
    }
}
 

private int getDay(IPreferenceStore pref) {
	String day = pref.getString(P_DAY);
	for (int d = 0; d < DAYS.length; d++)
		if (DAYS[d].equals(day))
			switch (d) {
				case 0 :
					return -1;
				case 1 :
					return Calendar.MONDAY;
				case 2 :
					return Calendar.TUESDAY;
				case 3 :
					return Calendar.WEDNESDAY;
				case 4 :
					return Calendar.THURSDAY;
				case 5 :
					return Calendar.FRIDAY;
				case 6 :
					return Calendar.SATURDAY;
				case 7 :
					return Calendar.SUNDAY;
			}
	return -1;
}
 

/**
 * TimeZone API.
 */
public int getOffset(int era, int year, int month,int dom, int dow, int millis, int monthLength){

    if ((era != GregorianCalendar.AD && era != GregorianCalendar.BC)
        || month < Calendar.JANUARY
        || month > Calendar.DECEMBER
        || dom < 1
        || dom > monthLength
        || dow < Calendar.SUNDAY
        || dow > Calendar.SATURDAY
        || millis < 0
        || millis >= Grego.MILLIS_PER_DAY
        || monthLength < 28
        || monthLength > 31) {
        throw new IllegalArgumentException();
    }

    if (era == GregorianCalendar.BC) {
        year = -year;
    }

    if (finalZone != null && year >= finalStartYear) {
        return finalZone.getOffset(era, year, month, dom, dow, millis);
    }

    // Compute local epoch millis from input fields
    long time = Grego.fieldsToDay(year, month, dom) * Grego.MILLIS_PER_DAY + millis;

    int[] offsets = new int[2];
    getHistoricalOffset(time, true, LOCAL_DST, LOCAL_STD, offsets);
    return offsets[0] + offsets[1];
}
 

public static int weekNumber(Timestamp input, int startOfWeek) {
    Calendar calendar = Calendar.getInstance();
    calendar.setFirstDayOfWeek(startOfWeek);

    if (startOfWeek == Calendar.MONDAY) {
       calendar.setMinimalDaysInFirstWeek(4);
    } else if (startOfWeek == Calendar.SUNDAY) {
       calendar.setMinimalDaysInFirstWeek(3);
    }

    calendar.setTime(new java.util.Date(input.getTime()));
    return calendar.get(Calendar.WEEK_OF_YEAR);
}
 

/**
 * @param start An integer in the range of <code>Calendar.SUNDAY</code>
 * to <code>Calendar.SATURDAY</code>
 * @param end An integer in the range of <code>Calendar.SUNDAY</code>
 * to <code>Calendar.SATURDAY</code>
 */
public DayOfWeekRange(int start, int end) {
    if (start < Calendar.SUNDAY || start > Calendar.SATURDAY) {
        throw new IllegalArgumentException("Invalid start argument");
    }
    if (end < Calendar.SUNDAY || end > Calendar.SATURDAY) {
        throw new IllegalArgumentException("Invalid end argument");
    }
    this.sequence = SEQUENCE_DOW_RANGE + start;
    this.start = start;
    this.end = end;
    if (Debug.verboseOn()) {
        Debug.logVerbose("Created " + this, module);
    }
}
 

private int getCalendarDay(String day) {
    if (day != null) {
        day = day.trim();
        if ("MO".equalsIgnoreCase(day)) {
            return Calendar.MONDAY;
        }
        if ("TU".equalsIgnoreCase(day)) {
            return Calendar.TUESDAY;
        }
        if ("WE".equalsIgnoreCase(day)) {
            return Calendar.WEDNESDAY;
        }
        if ("TH".equalsIgnoreCase(day)) {
            return Calendar.THURSDAY;
        }
        if ("FR".equalsIgnoreCase(day)) {
            return Calendar.FRIDAY;
        }
        if ("SA".equalsIgnoreCase(day)) {
            return Calendar.SATURDAY;
        }
        if ("SU".equalsIgnoreCase(day)) {
            return Calendar.SUNDAY;
        }
    }
    return 0;
}
 

/** Used to find the fisrt day in the TechDataCalendarWeek where capacity != 0, beginning at dayStart, dayStart included.
 *
 * @param techDataCalendarWeek        The TechDataCalendarWeek cover
 * @param dayStart
 * @return a map with the  capacity (Double) available and moveDay (int): the number of day it's necessary to move to have capacity available
 */
public static Map<String, Object> dayStartCapacityAvailable(GenericValue techDataCalendarWeek,  int  dayStart) {
    Map<String, Object> result = new HashMap<String, Object>();
    int moveDay = 0;
    Double capacity = null;
    Time startTime = null;
    while (capacity == null || capacity ==0) {
        switch (dayStart) {
            case Calendar.MONDAY:
                capacity =  techDataCalendarWeek.getDouble("mondayCapacity");
                startTime =  techDataCalendarWeek.getTime("mondayStartTime");
                break;
            case Calendar.TUESDAY:
                capacity =  techDataCalendarWeek.getDouble("tuesdayCapacity");
                startTime =  techDataCalendarWeek.getTime("tuesdayStartTime");
                break;
            case Calendar.WEDNESDAY:
                capacity =  techDataCalendarWeek.getDouble("wednesdayCapacity");
                startTime =  techDataCalendarWeek.getTime("wednesdayStartTime");
                break;
            case Calendar.THURSDAY:
                capacity =  techDataCalendarWeek.getDouble("thursdayCapacity");
                startTime =  techDataCalendarWeek.getTime("thursdayStartTime");
                break;
            case Calendar.FRIDAY:
                capacity =  techDataCalendarWeek.getDouble("fridayCapacity");
                startTime =  techDataCalendarWeek.getTime("fridayStartTime");
                break;
            case Calendar.SATURDAY:
                capacity =  techDataCalendarWeek.getDouble("saturdayCapacity");
                startTime =  techDataCalendarWeek.getTime("saturdayStartTime");
                break;
            case Calendar.SUNDAY:
                capacity =  techDataCalendarWeek.getDouble("sundayCapacity");
                startTime =  techDataCalendarWeek.getTime("sundayStartTime");
                break;
        }
        if (capacity == null || capacity == 0) {
            moveDay +=1;
            dayStart = (dayStart==7) ? 1 : dayStart +1;
        }
    }
    result.put("capacity",capacity);
    result.put("startTime",startTime);
    result.put("moveDay", moveDay);
    return result;
}
 

/** Used to find the last day in the TechDataCalendarWeek where capacity != 0, ending at dayEnd, dayEnd included.
 *
 * @param techDataCalendarWeek        The TechDataCalendarWeek cover
 * @param dayEnd
 * @return a map with the  capacity (Double) available, the startTime and  moveDay (int): the number of day it's necessary to move to have capacity available
 */
public static Map<String, Object> dayEndCapacityAvailable(GenericValue techDataCalendarWeek, int dayEnd) {
    Map<String, Object> result = new HashMap<String, Object>();
    int moveDay = 0;
    Double capacity = null;
    Time startTime = null;
    while (capacity == null || capacity == 0) {
        switch (dayEnd) {
            case Calendar.MONDAY:
                capacity =  techDataCalendarWeek.getDouble("mondayCapacity");
                startTime =  techDataCalendarWeek.getTime("mondayStartTime");
                break;
            case Calendar.TUESDAY:
                capacity =  techDataCalendarWeek.getDouble("tuesdayCapacity");
                startTime =  techDataCalendarWeek.getTime("tuesdayStartTime");
                break;
            case Calendar.WEDNESDAY:
                capacity =  techDataCalendarWeek.getDouble("wednesdayCapacity");
                startTime =  techDataCalendarWeek.getTime("wednesdayStartTime");
                break;
            case Calendar.THURSDAY:
                capacity =  techDataCalendarWeek.getDouble("thursdayCapacity");
                startTime =  techDataCalendarWeek.getTime("thursdayStartTime");
                break;
            case Calendar.FRIDAY:
                capacity =  techDataCalendarWeek.getDouble("fridayCapacity");
                startTime =  techDataCalendarWeek.getTime("fridayStartTime");
                break;
            case Calendar.SATURDAY:
                capacity =  techDataCalendarWeek.getDouble("saturdayCapacity");
                startTime =  techDataCalendarWeek.getTime("saturdayStartTime");
                break;
            case Calendar.SUNDAY:
                capacity =  techDataCalendarWeek.getDouble("sundayCapacity");
                startTime =  techDataCalendarWeek.getTime("sundayStartTime");
                break;
        }
        if (capacity == null || capacity == 0) {
            moveDay -=1;
            dayEnd = (dayEnd==1) ? 7 : dayEnd - 1;
        }
    }
    result.put("capacity",capacity);
    result.put("startTime",startTime);
    result.put("moveDay", moveDay);
    return result;
}