Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Logback: the reliable, generic, fast and flexible logging framework. Copyright (C) 1999-2011, QOS.ch. All rights reserved. This program and the accompanying materials are dual-licensed under either the terms of the Eclipse Public License v1.0 as published by the Eclipse Foundation or (per the licensee's choosing) under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation.
 
 package ch.qos.logback.core.rolling.helper;
 
 import java.util.Date;
 
RollingCalendar is a helper class to or similar timed-based rolling policies. Given a periodicity type and the current time, it computes the start of the next interval (i.e. the triggering date).

Author(s):
Ceki Gülcü
 
 public class RollingCalendar extends GregorianCalendar {
 
   private static final long serialVersionUID = -5937537740925066161L;
 
   // The gmtTimeZone is used only in computeCheckPeriod() method.
   static final TimeZone GMT_TIMEZONE = TimeZone.getTimeZone("GMT");
 
 
   public RollingCalendar() {
     super();
   }
 
   public RollingCalendar(TimeZone tzLocale locale) {
     super(tzlocale);
   }
 
   public void init(String datePattern) {
      = computePeriodicityType(datePattern);
   }
 
   private void setPeriodicityType(PeriodicityType periodicityType) {
     this. = periodicityType;
   }
 
     return ;
   }
 
   public long getNextTriggeringMillis(Date now) {
     return getNextTriggeringDate(now).getTime();
   }
 
   // This method computes the roll over period by looping over the
   // periods, starting with the shortest, and stopping when the r0 is
   // different from from r1, where r0 is the epoch formatted according
   // the datePattern (supplied by the user) and r1 is the
   // epoch+nextMillis(i) formatted according to datePattern. All date
   // formatting is done in GMT and not local format because the test
   // logic is based on comparisons relative to 1970-01-01 00:00:00
   // GMT (the epoch).
   public PeriodicityType computePeriodicityType(String datePattern) {
     RollingCalendar rollingCalendar = new RollingCalendar(, Locale
             .getDefault());
 
     // set sate to 1970-01-01 00:00:00 GMT
     Date epoch = new Date(0);
 
     if (datePattern != null) {
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(datePattern);
         simpleDateFormat.setTimeZone(); // all date formatting done
         // in GMT
 
         String r0 = simpleDateFormat.format(epoch);
         rollingCalendar.setPeriodicityType(i);
 
         Date next = new Date(rollingCalendar.getNextTriggeringMillis(epoch));
         String r1 = simpleDateFormat.format(next);
 
         // System.out.println("Type = "+i+", r0 = "+r0+", r1 = "+r1);
         if ((r0 != null) && (r1 != null) && !r0.equals(r1)) {
           return i;
         }
       }
     }
    // we failed
    return .;
  }
  public void printPeriodicity(ContextAwareBase cab) {
    switch () {
      case :
        cab.addInfo("Roll-over every millisecond.");
        break;
      case :
        cab.addInfo("Roll-over every second.");
        break;
      case :
        cab.addInfo("Roll-over every minute.");
        break;
      case :
        cab.addInfo("Roll-over at the top of every hour.");
        break;
      case :
        cab.addInfo("Roll-over at midday and midnight.");
        break;
      case :
        cab.addInfo("Roll-over at midnight.");
        break;
      case :
        cab.addInfo("Rollover at the start of week.");
        break;
      case :
        cab.addInfo("Rollover at start of every month.");
        break;
      default:
        cab.addInfo("Unknown periodicity.");
    }
  }
  public long periodsElapsed(long startlong end) {
    if (start > end)
      throw new IllegalArgumentException("Start cannot come before end");
    long diff = end - start;
    switch () {
      case :
        return diff;
      case :
        return diff / .;
      case :
        return diff / .;
      case :
        return (intdiff / .;
      case :
        return diff / .;
      case :
        return diff / .;
      case :
        return diffInMonths(startend);
      default:
        throw new IllegalStateException("Unknown periodicity type.");
    }
  }
  public static int diffInMonths(long startTimelong endTime) {
    if (startTime > endTime)
      throw new IllegalArgumentException("startTime cannot be larger than endTime");
    Calendar startCal = Calendar.getInstance();
    startCal.setTimeInMillis(startTime);
    Calendar endCal = Calendar.getInstance();
    endCal.setTimeInMillis(endTime);
    int yearDiff = endCal.get(.) - startCal.get(.);
    int monthDiff = endCal.get(.) - startCal.get(.);
    return yearDiff * 12 + monthDiff;
  }
  public Date getRelativeDate(Date nowint periods) {
    this.setTime(now);
    switch () {
      case :
        this.add(.periods);
        break;
      case :
        this.set(., 0);
        this.add(.periods);
        break;
      case :
        this.set(., 0);
        this.set(., 0);
        this.add(.periods);
        break;
      case :
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.add(.periods);
        break;
      case :
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.add(.periods);
        break;
      case :
        this.set(.getFirstDayOfWeek());
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.add(.periods);
        break;
      case :
        this.set(., 1);
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.set(., 0);
        this.add(.periods);
        break;
      default:
        throw new IllegalStateException("Unknown periodicity type.");
    }
    return getTime();
  }
  public Date getNextTriggeringDate(Date now) {
    return getRelativeDate(now, 1);
  }
New to GrepCode? Check out our FAQ X