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

/**
 * @param start Starting date, defaults to current system time
 * @param freqType One of the following integer values: <code>Calendar.SECOND
 * Calendar.MINUTE Calendar.HOUR Calendar.DAY_OF_MONTH Calendar.MONTH
 * Calendar.YEAR</code>
 * @param freqCount A positive integer
 */
public Frequency(Date start, int freqType, int freqCount) {
    if (freqType != Calendar.SECOND && freqType != Calendar.MINUTE
            && freqType != Calendar.HOUR && freqType != Calendar.DAY_OF_MONTH
            && freqType != Calendar.MONTH && freqType != Calendar.YEAR) {
        throw new IllegalArgumentException("Invalid freqType argument");
    }
    if (freqCount < 1) {
        throw new IllegalArgumentException("freqCount argument must be a positive integer");
    }
    if (start != null) {
        this.start = (Date) start.clone();
    } else {
        this.start = new Date();
    }
    this.sequence = SEQUENCE_FREQ + freqType;
    this.freqType = freqType;
    this.freqCount = freqCount;
    if (Debug.verboseOn()) {
        Debug.logVerbose("Created " + this, module);
    }
}
 

@Override
public void visit(TemporalExpressions.Frequency expr) {
    if (this.dateStart == null) {
        this.dateStart = new DtStart(new net.fortuna.ical4j.model.Date(expr.getStartDate()));
    }
    int freqCount = expr.getFreqCount();
    int freqType = expr.getFreqType();
    switch (freqType) {
    case Calendar.SECOND:
        this.state.addRecur((new Recur(Recur.SECONDLY, freqCount)));
        break;
    case Calendar.MINUTE:
        this.state.addRecur((new Recur(Recur.MINUTELY, freqCount)));
        break;
    case Calendar.HOUR:
        this.state.addRecur((new Recur(Recur.HOURLY, freqCount)));
        break;
    case Calendar.DAY_OF_MONTH:
        this.state.addRecur((new Recur(Recur.DAILY, freqCount)));
        break;
    case Calendar.MONTH:
        this.state.addRecur((new Recur(Recur.MONTHLY, freqCount)));
        break;
    case Calendar.YEAR:
        this.state.addRecur((new Recur(Recur.YEARLY, freqCount)));
        break;
    default:
        break;
    }
}
 

protected Calendar prepareCal(Calendar cal) {
    // Performs a "sane" skip forward in time - avoids time consuming loops
    // like incrementing every second from Jan 1 2000 until today
    Calendar skip = (Calendar) cal.clone();
    skip.setTime(this.start);
    long deltaMillis = cal.getTimeInMillis() - this.start.getTime();
    if (deltaMillis < 1000) {
        return skip;
    }
    long divisor = deltaMillis;
    if (this.freqType == Calendar.DAY_OF_MONTH) {
        divisor = 86400000;
    } else if (this.freqType == Calendar.HOUR) {
        divisor = 3600000;
    } else if (this.freqType == Calendar.MINUTE) {
        divisor = 60000;
    } else if (this.freqType == Calendar.SECOND) {
        divisor = 1000;
    } else {
        return skip;
    }
    long units = deltaMillis / divisor;
    units -= units % this.freqCount;
    skip.add(this.freqType, (int)units);
    while (skip.after(cal)) {
        skip.add(this.freqType, -this.freqCount);
    }
    return skip;
}
 

/**
 * Returns a preferred format specifier for tick labels that represent axis
 * values that will be computed based on the difference between cdt1 and
 * cdt2
 * 
 * @param iUnit
 *            The unit for which a preferred pattern is being requested
 * @param locale
 *            The locale for format style
 * @param keepHierarchy
 *            indicates if the format should keep hierarchy
 * 
 * @return A preferred datetime format for the given unit
 */
public static final IDateFormatWrapper getPreferredDateFormat( int iUnit,
		ULocale locale, boolean keepHierarchy )
{
	IDateFormatWrapper df = null;
	String pattern = ChartUtil.createDefaultFormatPattern( iUnit,
			keepHierarchy );
	df = new CommonDateFormatWrapper( new SimpleDateFormat( pattern, locale ) );
	// Special cases for dynamic patterns
	switch ( iUnit )
	{
		case Calendar.MONTH :
			if ( keepHierarchy )
			{
				df = new MonthDateFormat( locale );
			}
			break;
		case Calendar.DAY_OF_MONTH :// Same as DATE
			if ( keepHierarchy )
			{
				df = new CommonDateFormatWrapper( DateFormat.getDateInstance( DateFormat.MEDIUM,
						locale ) );
			}
			break;
	}
	return df;
}
 

/**
 * Convert GroupingUnit type to CDateUnit type.
 * 
 * @param groupingUnitType the GroupingUnit type.
 * @return CDateUnit type of integer.
    * @since 2.3, it is merged from <code>DataProcessor</code>, make the method to be a static usage.
 */
public static int groupingUnit2CDateUnit( GroupingUnitType groupingUnitType )
{
	if ( groupingUnitType != null )
	{
		switch ( groupingUnitType.getValue( ) )
		{
			case GroupingUnitType.SECONDS :
				return Calendar.SECOND;
			case GroupingUnitType.MINUTES :
				return Calendar.MINUTE;
			case GroupingUnitType.HOURS :
				return Calendar.HOUR_OF_DAY;
			case GroupingUnitType.DAYS :
			case GroupingUnitType.DAY_OF_MONTH :
				return Calendar.DAY_OF_MONTH;
			case GroupingUnitType.DAY_OF_QUARTER :
				return CDateTime.DAY_OF_QUARTER;
			case GroupingUnitType.DAY_OF_WEEK :
				return Calendar.DAY_OF_WEEK;
			case GroupingUnitType.DAY_OF_YEAR :
				return Calendar.DAY_OF_YEAR;
			case GroupingUnitType.WEEKS :
			case GroupingUnitType.WEEK_OF_MONTH :
				return Calendar.WEEK_OF_MONTH;
			case GroupingUnitType.WEEK_OF_YEAR :
				return Calendar.WEEK_OF_YEAR;
			case GroupingUnitType.MONTHS :
				return Calendar.MONTH;
			case GroupingUnitType.QUARTERS :
				return CDateTime.QUARTER;
			case GroupingUnitType.YEARS :
				return Calendar.YEAR;
			case GroupingUnitType.WEEK_OF_QUARTER :
				return CDateTime.WEEK_OF_QUARTER;
		}
	}

	return Calendar.MILLISECOND;
}
 

public static int getFieldIndex( String fieldName )
{
 if( fieldName.equals( YEAR ) )
  return Calendar.YEAR;
 else if( fieldName.equals( MONTH ) )
  return Calendar.MONTH;
 else if( fieldName.equals( WEEK_OF_YEAR ) )
  return Calendar.WEEK_OF_YEAR;
 else if( fieldName.equals( WEEK_OF_MONTH ) )
  return Calendar.WEEK_OF_MONTH;
 else if( fieldName.equals( DAY_OF_MONTH ) )
  return Calendar.DAY_OF_MONTH;
 else if( fieldName.equals( DAY_OF_YEAR ) )
  return Calendar.DAY_OF_YEAR;
 else if( fieldName.equals( DAY_OF_WEEK ) )
  return Calendar.DAY_OF_WEEK;
 else if( fieldName.equals( HOUR ) )
  return Calendar.HOUR;
 else if( fieldName.equals( HOUR_OF_DAY ) )
  return Calendar.HOUR_OF_DAY;
 else if( fieldName.equals( MINUTE ) )
  return Calendar.MINUTE;
 else if( fieldName.equals( SECOND ) )
  return Calendar.SECOND;
 else if( fieldName.equals( MILLISECOND ) )
  return Calendar.MILLISECOND;
 return -1;
}
 

public static String getFieldName( int fieldIndex )
 {
switch (fieldIndex) 
{
case Calendar.YEAR:
	return YEAR;
case Calendar.MONTH:
	return MONTH;
case Calendar.WEEK_OF_YEAR:
	return WEEK_OF_YEAR;
case Calendar.WEEK_OF_MONTH:
	return WEEK_OF_MONTH;
case Calendar.DAY_OF_MONTH:
	return DAY_OF_MONTH;
case Calendar.DAY_OF_YEAR:
	return DAY_OF_YEAR;
case Calendar.DAY_OF_WEEK:
	return DAY_OF_WEEK;
case Calendar.HOUR:
	return HOUR;
case Calendar.HOUR_OF_DAY:
	return HOUR_OF_DAY;
case Calendar.MINUTE:
	return MINUTE;
case Calendar.SECOND:
	return SECOND;
case Calendar.MILLISECOND:
	return MILLISECOND;
}
return null;
 }
 

/**
 * Provides a way for client to build interval patterns.
 * User could construct DateIntervalInfo by providing
 * a list of skeletons and their patterns.
 * <P>
 * For example:
 * <pre>
 * DateIntervalInfo dIntervalInfo = new DateIntervalInfo();
 * dIntervalInfo.setIntervalPattern("yMd", Calendar.YEAR, "'from' yyyy-M-d 'to' yyyy-M-d");
 * dIntervalInfo.setIntervalPattern("yMMMd", Calendar.MONTH, "'from' yyyy MMM d 'to' MMM d");
 * dIntervalInfo.setIntervalPattern("yMMMd", Calendar.DAY, "yyyy MMM d-d");
 * dIntervalInfo.setFallbackIntervalPattern("{0} ~ {1}");
 * </pre>
 *
 * Restriction:
 * Currently, users can only set interval patterns when the following
 * calendar fields are different: ERA, YEAR, MONTH, DATE,  DAY_OF_MONTH,
 * DAY_OF_WEEK, AM_PM,  HOUR, HOUR_OF_DAY, MINUTE, and SECOND.
 * Interval patterns when other calendar fields are different are
 * not supported.
 *
 * @param skeleton         the skeleton on which interval pattern based
 * @param lrgDiffCalUnit   the largest different calendar unit.
 * @param intervalPattern  the interval pattern on the largest different
 *                         calendar unit.
 *                         For example, if lrgDiffCalUnit is
 *                         "year", the interval pattern for en_US when year
 *                         is different could be "'from' yyyy 'to' yyyy".
 * @throws IllegalArgumentException  if setting interval pattern on
 *                            a calendar field that is smaller
 *                            than the MINIMUM_SUPPORTED_CALENDAR_FIELD
 * @throws UnsupportedOperationException  if the object is frozen
 * @stable ICU 4.0
 */
public void setIntervalPattern(String skeleton,
                               int lrgDiffCalUnit,
                               String intervalPattern)
{
    if ( frozen ) {
        throw new UnsupportedOperationException("no modification is allowed after DII is frozen");
    }
    if ( lrgDiffCalUnit > MINIMUM_SUPPORTED_CALENDAR_FIELD ) {
        throw new IllegalArgumentException("calendar field is larger than MINIMUM_SUPPORTED_CALENDAR_FIELD");
    }
    if (fIntervalPatternsReadOnly) {
        fIntervalPatterns = cloneIntervalPatterns(fIntervalPatterns);
        fIntervalPatternsReadOnly = false;
    }
    PatternInfo ptnInfo = setIntervalPatternInternally(skeleton,
                      CALENDAR_FIELD_TO_PATTERN_LETTER[lrgDiffCalUnit],
                      intervalPattern);
    if ( lrgDiffCalUnit == Calendar.HOUR_OF_DAY ) {
        setIntervalPattern(skeleton,
                           CALENDAR_FIELD_TO_PATTERN_LETTER[Calendar.AM_PM],
                           ptnInfo);
        setIntervalPattern(skeleton,
                           CALENDAR_FIELD_TO_PATTERN_LETTER[Calendar.HOUR],
                           ptnInfo);
    } else if ( lrgDiffCalUnit == Calendar.DAY_OF_MONTH ||
                lrgDiffCalUnit == Calendar.DAY_OF_WEEK ) {
        setIntervalPattern(skeleton,
                           CALENDAR_FIELD_TO_PATTERN_LETTER[Calendar.DATE],
                           ptnInfo);
    }
}