Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.goda.chronic.repeaters;
  
  import java.util.List;
 
 
 
 public class RepeaterTime extends Repeater<Tick> {
   private static final String TIME_PATTERN = "^\\d{1,2}(:?\\d{2})?([\\.:]?\\d{2})?$";
 
   public RepeaterTime(String time) {
     super(null);
     String t = time.replaceAll(":""");
     Tick type;
     int length = t.length();
     if (length <= 2) {
       double hours = Double.parseDouble(t);
       int hoursInSeconds = (int) Math.round(hours * 60D * 60D);
       if (hours == 12) {
         type = new Tick(0 * 60 * 60, true);
       }
       else {
         type = new Tick(hoursInSecondstrue);
       }
     }
     else if (length == 3) {
       int hoursInSeconds = (int) (Double.parseDouble(t.substring(0, 1)) * 60 * 60);
       int minutesInSeconds = (int) (Double.parseDouble(t.substring(1)) * 60D);
       type = new Tick(hoursInSeconds + minutesInSecondstrue);
     }
     else if (length == 4) {
       boolean ambiguous = (time.contains(":") && Integer.parseInt(t.substring(0, 1)) != 0 && Integer.parseInt(t.substring(0, 2)) <= 12);
       double hours = Double.parseDouble(t.substring(0, 2));
       int hoursInSeconds = (int)(hours * 60 * 60);
       int minutesInSeconds = (int)(Double.parseDouble(t.substring(2)) * 60);
       if (hours == 12) {
         type = new Tick(0 * 60 * 60 + minutesInSecondsambiguous);
       }
       else {
         type = new Tick(hoursInSeconds + minutesInSecondsambiguous);
       }
     }
     else if (length == 5) {
       int hoursInSeconds = (int)(Double.parseDouble(t.substring(0, 1)) * 60 * 60);
       int minutesInSeconds =(int)(Double.parseDouble(t.substring(1, 3)) * 60);
       int seconds = (int) Double.parseDouble(t.substring(3));
       type = new Tick(hoursInSeconds + minutesInSeconds + secondstrue);
     }
     else if (length == 6) {
       boolean ambiguous = (time.contains(":") && Integer.parseInt(t.substring(0, 1)) != 0 && Integer.parseInt(t.substring(0, 2)) <= 12);
       int hours = Integer.parseInt(t.substring(0, 2));
       int hoursInSeconds = hours * 60 * 60;
       int minutesInSeconds = Integer.parseInt(t.substring(2, 4)) * 60;
       int seconds = Integer.parseInt(t.substring(4, 6));
       //type = new Tick(hoursInSeconds + minutesInSeconds + seconds, ambiguous);
       if (hours == 12) {
         type = new Tick(0 * 60 * 60 + minutesInSeconds + secondsambiguous);
       }
       else {
         type = new Tick(hoursInSeconds + minutesInSeconds + secondsambiguous);
       }
     }
     else {
       throw new IllegalArgumentException("Time cannot exceed six digits");
     }
     setType(type);
   }
 
   private DateTime _currentTime;
 
   @Override
   protected MutableInterval _nextMutableInterval(PointerType pointer) {
     int halfDay = . / 2;
     int fullDay = .;
 
     DateTime now = getNow();
     Tick tick = getType();
     boolean first = false;
     if ( == null) {
       first = true;
       DateTime midnight = Time.ymd(now);
       DateTime yesterdayMidnight = midnight.minusSeconds(fullDay);
       DateTime tomorrowMidnight = midnight.plusSeconds(fullDay);
       boolean done = false;
       if (pointer == ..) {
         if (tick.isAmbiguous()) {
           List<DateTimefutureDates = new LinkedList<DateTime>();
           futureDates.addmidnight.plusSeconds(tick.intValue()));
           futureDates.add(midnight.plusSecondshalfDay + tick.intValue()));
           futureDates.add(tomorrowMidnight.plusSeconds(tick.intValue()));
          for (DateTime futureDate : futureDates) {
            if (futureDate.getMillis() > now.getMillis() || futureDate.equals(now)) {
               = futureDate;
              done = true;
              break;
            }
          }
        }
        else {
          List<DateTimefutureDates = new LinkedList<DateTime>();
          futureDates.add(midnight.plusSeconds(tick.intValue()));
          futureDates.add(tomorrowMidnight.plusSeconds(tick.intValue()));
          for (DateTime futureDate : futureDates) {
            if (futureDate.getMillis() > now.getMillis() || futureDate.equals(now)) {
               = futureDate;
              done = true;
              break;
            }
          }
        }
      }
      else {
        if (tick.isAmbiguous()) {
          List<DateTimepastDates = new LinkedList<DateTime>();
          pastDates.add(midnight.plusSeconds(halfDay + tick.intValue()));
          pastDates.add(midnight.plusSeconds(tick.intValue()));
          pastDates.add(yesterdayMidnight.plusSeconds(tick.intValue() * 2));
          for (DateTime pastDate : pastDates) {
            if (pastDate.getMillis() > now.getMillis() || pastDate.equals(now)) {
               = pastDate;
              done = true;
              break;
            }
          }
        }
        else {
          List<DateTimepastDates = new LinkedList<DateTime>();
          pastDates.add(midnight.plusSecondstick.intValue()));
          pastDates.add(yesterdayMidnight.plusSecondstick.intValue()));
          for (DateTime pastDate : pastDates) {
            if (pastDate.getMillis() > now.getMillis() || pastDate.equals(now)) {
               = pastDate;
              done = true;
              break;
            }
          }
        }
      }
      if (!done &&  == null) {
        throw new IllegalStateException("Current time cannot be null at this point.");
      }
    }
    if (!first) {
      int increment = (tick.isAmbiguous()) ? halfDay : fullDay;
      int direction = (pointer == ..) ? 1 : -1;
       = .plusSecondsdirection * increment);
    }
  }
    if (pointer == ..) {
      pointer = ..;
    }
    return nextMutableInterval(pointer);
  }
  public MutableInterval getOffset(MutableInterval MutableIntervaldouble amountPointerType pointer) {
    throw new IllegalStateException("Not implemented.");
  }
  public int getWidth() {
    return 1;
  }
  public String toString() {
    return super.toString() + "-time-" + getType();
  }
  public static RepeaterTime scan(Token tokenList<TokentokensOptions options) {
    if (token.getWord().matches.)) {
      return new RepeaterTime(token.getWord());
    }
    Integer intStrValue = StringUtils.integerValue(token.getWord());
    if (intStrValue != null) {
      return new RepeaterTime(intStrValue.toString());
    }
    return null;
  }
New to GrepCode? Check out our FAQ X