org.joda.time.ReadWritablePeriod Java Examples

void setFieldValue(ReadWritablePeriod period, int field, int value) {
    switch (field) {
    default:
        break;
    case YEARS:
        period.setYears(value);
        break;
    case MONTHS:
        period.setMonths(value);
        break;
    case WEEKS:
        period.setWeeks(value);
        break;
    case DAYS:
        period.setDays(value);
        break;
    case HOURS:
        period.setHours(value);
        break;
    case MINUTES:
        period.setMinutes(value);
        break;
    case SECONDS:
        period.setSeconds(value);
        break;
    case MILLIS:
        period.setMillis(value);
        break;
    }
}
 

/**
 * Extracts duration values from an object of this converter's type, and
 * sets them into the given ReadWritableDuration.
 *
 * @param period  period to get modified
 * @param object  the String to convert, must not be null
 * @param chrono  the chronology to use
 * @return the millisecond duration
 * @throws ClassCastException if the object is invalid
 */
public void setInto(ReadWritablePeriod period, Object object, Chronology chrono) {
    String str = (String) object;
    PeriodFormatter parser = ISOPeriodFormat.standard();
    period.clear();
    int pos = parser.parseInto(period, str, 0);
    if (pos < str.length()) {
        if (pos < 0) {
            // Parse again to get a better exception thrown.
            parser.withParseType(period.getPeriodType()).parseMutablePeriod(str);
        }
        throw new IllegalArgumentException("Invalid format: \"" + str + '"');
    }
}
 

/**
 * Sets the values of the mutable duration from the specified interval.
 * 
 * @param writablePeriod  the period to modify
 * @param object  the interval to set from
 * @param chrono  the chronology to use
 */
public void setInto(ReadWritablePeriod writablePeriod, Object object, Chronology chrono) {
    ReadableInterval interval = (ReadableInterval) object;
    chrono = (chrono != null ? chrono : DateTimeUtils.getIntervalChronology(interval));
    long start = interval.getStartMillis();
    long end = interval.getEndMillis();
    int[] values = chrono.get(writablePeriod, start, end);
    for (int i = 0; i < values.length; i++) {
        writablePeriod.setValue(i, values[i]);
    }
}
 

void setFieldValue(ReadWritablePeriod period, int field, int value) {
    switch (field) {
    default:
        break;
    case YEARS:
        period.setYears(value);
        break;
    case MONTHS:
        period.setMonths(value);
        break;
    case WEEKS:
        period.setWeeks(value);
        break;
    case DAYS:
        period.setDays(value);
        break;
    case HOURS:
        period.setHours(value);
        break;
    case MINUTES:
        period.setMinutes(value);
        break;
    case SECONDS:
        period.setSeconds(value);
        break;
    case MILLIS:
        period.setMillis(value);
        break;
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    if (periodStr.regionMatches(true, position, iText, 0, iText.length())) {
        return position + iText.length();
    }
    return ~position;
}
 

/**
 * Creates a new period based on another using the {@link ConverterManager}.
 *
 * @param period  the period to convert
 * @param type  which set of fields this period supports, null means use type from object
 * @param chrono  the chronology to use, null means ISO default
 * @throws IllegalArgumentException if period is invalid
 * @throws IllegalArgumentException if an unsupported field's value is non-zero
 */
protected BasePeriod(Object period, PeriodType type, Chronology chrono) {
    super();
    PeriodConverter converter = ConverterManager.getInstance().getPeriodConverter(period);
    type = (type == null ? converter.getPeriodType(period) : type);
    type = checkPeriodType(type);
    iType = type;
    if (this instanceof ReadWritablePeriod) {
        iValues = new int[size()];
        chrono = DateTimeUtils.getChronology(chrono);
        converter.setInto((ReadWritablePeriod) this, period, chrono);
    } else {
        iValues = new MutablePeriod(period, type, chrono).getValues();
    }
}
 

@Override
public Object create(Object request, SpecimenContext context) {
    if (!(request.equals(ReadablePeriod.class) || request.equals(ReadWritablePeriod.class)))
        return new NoSpecimen();

    DateTime dateA = (DateTime) context.resolve(DateTime.class);
    DateTime dateB = (DateTime) context.resolve(DateTime.class);

    if (dateA.isBefore(dateB))
        return new MutablePeriod(dateA, dateB);
    else
        return new MutablePeriod(dateB, dateA);
}
 

/**
 * Creates a new period based on another using the {@link ConverterManager}.
 *
 * @param period  the period to convert
 * @param type  which set of fields this period supports, null means use type from object
 * @param chrono  the chronology to use, null means ISO default
 * @throws IllegalArgumentException if period is invalid
 * @throws IllegalArgumentException if an unsupported field's value is non-zero
 */
protected BasePeriod(Object period, PeriodType type, Chronology chrono) {
    super();
    PeriodConverter converter = ConverterManager.getInstance().getPeriodConverter(period);
    type = (type == null ? converter.getPeriodType(period) : type);
    type = checkPeriodType(type);
    iType = type;
    if (this instanceof ReadWritablePeriod) {
        iValues = new int[size()];
        chrono = DateTimeUtils.getChronology(chrono);
        converter.setInto((ReadWritablePeriod) this, period, chrono);
    } else {
        iValues = new MutablePeriod(period, type, chrono).getValues();
    }
}
 

/**
 * Creates a new period based on another using the {@link ConverterManager}.
 *
 * @param period  the period to convert
 * @param type  which set of fields this period supports, null means use type from object
 * @param chrono  the chronology to use, null means ISO default
 * @throws IllegalArgumentException if period is invalid
 * @throws IllegalArgumentException if an unsupported field's value is non-zero
 */
protected BasePeriod(Object period, PeriodType type, Chronology chrono) {
    super();
    PeriodConverter converter = ConverterManager.getInstance().getPeriodConverter(period);
    type = (type == null ? converter.getPeriodType(period) : type);
    type = checkPeriodType(type);
    iType = type;
    if (this instanceof ReadWritablePeriod) {
        iValues = new int[size()];
        chrono = DateTimeUtils.getChronology(chrono);
        converter.setInto((ReadWritablePeriod) this, period, chrono);
    } else {
        iValues = new MutablePeriod(period, type, chrono).getValues();
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    PeriodParser[] parsers = iParsers;
    if (parsers == null) {
        throw new UnsupportedOperationException();
    }

    int len = parsers.length;
    for (int i=0; i<len && position >= 0; i++) {
        position = parsers[i].parseInto(period, periodStr, position, locale);
    }
    return position;
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    PeriodParser[] parsers = iParsers;
    if (parsers == null) {
        throw new UnsupportedOperationException();
    }

    int len = parsers.length;
    for (int i=0; i<len && position >= 0; i++) {
        position = parsers[i].parseInto(period, periodStr, position, locale);
    }
    return position;
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    if (periodStr.regionMatches(true, position, iText, 0, iText.length())) {
        return position + iText.length();
    }
    return ~position;
}
 

void setFieldValue(ReadWritablePeriod period, int field, int value) {
    switch (field) {
    default:
        break;
    case YEARS:
        period.setYears(value);
        break;
    case MONTHS:
        period.setMonths(value);
        break;
    case WEEKS:
        period.setWeeks(value);
        break;
    case DAYS:
        period.setDays(value);
        break;
    case HOURS:
        period.setHours(value);
        break;
    case MINUTES:
        period.setMinutes(value);
        break;
    case SECONDS:
        period.setSeconds(value);
        break;
    case MILLIS:
        period.setMillis(value);
        break;
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    PeriodParser[] parsers = iParsers;
    if (parsers == null) {
        throw new UnsupportedOperationException();
    }

    int len = parsers.length;
    for (int i=0; i<len && position >= 0; i++) {
        position = parsers[i].parseInto(period, periodStr, position, locale);
    }
    return position;
}
 

/**
 * Creates a new period based on another using the {@link ConverterManager}.
 *
 * @param period  the period to convert
 * @param type  which set of fields this period supports, null means use type from object
 * @param chrono  the chronology to use, null means ISO default
 * @throws IllegalArgumentException if period is invalid
 * @throws IllegalArgumentException if an unsupported field's value is non-zero
 */
protected BasePeriod(Object period, PeriodType type, Chronology chrono) {
    super();
    PeriodConverter converter = ConverterManager.getInstance().getPeriodConverter(period);
    type = (type == null ? converter.getPeriodType(period) : type);
    type = checkPeriodType(type);
    iType = type;
    if (this instanceof ReadWritablePeriod) {
        iValues = new int[size()];
        chrono = DateTimeUtils.getChronology(chrono);
        converter.setInto((ReadWritablePeriod) this, period, chrono);
    } else {
        iValues = new MutablePeriod(period, type, chrono).getValues();
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    if (periodStr.regionMatches(true, position, iText, 0, iText.length())) {
        return position + iText.length();
    }
    return ~position;
}
 

void setFieldValue(ReadWritablePeriod period, int field, int value) {
    switch (field) {
    default:
        break;
    case YEARS:
        period.setYears(value);
        break;
    case MONTHS:
        period.setMonths(value);
        break;
    case WEEKS:
        period.setWeeks(value);
        break;
    case DAYS:
        period.setDays(value);
        break;
    case HOURS:
        period.setHours(value);
        break;
    case MINUTES:
        period.setMinutes(value);
        break;
    case SECONDS:
        period.setSeconds(value);
        break;
    case MILLIS:
        period.setMillis(value);
        break;
    }
}
 

@Override
public int parseInto(ReadWritablePeriod period, String text, int position, Locale locale)
{
    int bestValidPos = position;
    ReadWritablePeriod bestValidPeriod = null;

    int bestInvalidPos = position;

    for (PeriodParser parser : parsers) {
        ReadWritablePeriod parsedPeriod = new MutablePeriod();
        int parsePos = parser.parseInto(parsedPeriod, text, position, locale);
        if (parsePos >= position) {
            if (parsePos > bestValidPos) {
                bestValidPos = parsePos;
                bestValidPeriod = parsedPeriod;
                if (parsePos >= text.length()) {
                    break;
                }
            }
        }
        else if (parsePos < 0) {
            parsePos = ~parsePos;
            if (parsePos > bestInvalidPos) {
                bestInvalidPos = parsePos;
            }
        }
    }

    if (bestValidPos > position || (bestValidPos == position)) {
        // Restore the state to the best valid parse.
        if (bestValidPeriod != null) {
            period.setPeriod(bestValidPeriod);
        }
        return bestValidPos;
    }

    return ~bestInvalidPos;
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    PeriodParser[] parsers = iParsers;
    if (parsers == null) {
        throw new UnsupportedOperationException();
    }

    int len = parsers.length;
    for (int i=0; i<len && position >= 0; i++) {
        position = parsers[i].parseInto(period, periodStr, position, locale);
    }
    return position;
}
 

/**
 * Convert an ISO8601 duration to a Period.
 * @param duration
 * @return
 * @throws WarpScriptException
 */
public static ReadWritablePeriodWithSubSecondOffset durationToPeriod(String duration) throws WarpScriptException {
  // Separate seconds from  digits below second precision
  String[] tokens = UnsafeString.split(duration, '.');

  long offset = 0;
  if (tokens.length > 2) {
    throw new WarpScriptException("Invalid ISO8601 duration");
  }

  if (2 == tokens.length) {
    duration = tokens[0].concat("S");
    String tmp = tokens[1].substring(0, tokens[1].length() - 1);

    try {
      offset = ((Double) (Double.parseDouble("0." + tmp) * Constants.TIME_UNITS_PER_S)).longValue();
    } catch (NumberFormatException e) {
      throw new WarpScriptException("Parsing of sub second precision part of duration has failed. tried to parse: " + tmp);
    }
  }

  ReadWritablePeriod period = new MutablePeriod();
  if (ISOPeriodFormat.standard().getParser().parseInto(period, duration, 0, Locale.US) < 0) {
    throw new WarpScriptException("Parsing of duration without sub second precision has failed. Tried to parse: " + duration);
  }

  return new ReadWritablePeriodWithSubSecondOffset(period, offset);
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    if (periodStr.regionMatches(true, position, iText, 0, iText.length())) {
        return position + iText.length();
    }
    return ~position;
}
 

/**
 * Add a duration in ISO8601 duration format to a timestamp
 * @param instant a timestamp since Unix Epoch
 * @param periodAndOffset a period (with subsecond precision) to add
 * @param dtz timezone
 * @param N number of times the period is added
 * @return resulting timestamp
 */
public static long addPeriod(long instant, ReadWritablePeriodWithSubSecondOffset periodAndOffset, DateTimeZone dtz, long N) {

  ReadWritablePeriod period = periodAndOffset.getPeriod();
  long offset = periodAndOffset.getOffset();

  //
  // Do the computation
  //

  DateTime dt = new DateTime(instant / Constants.TIME_UNITS_PER_MS, dtz);

  //
  // Add the duration
  // Note that for performance reasons we add N times ISO8601 duration, then N times the sub seconds offset.
  // This calculation is not exact in some rare edge cases  e.g. in the last second of the 28th february on a year before a leap year if we add 'P1YT0.999999S'.
  //

  long M = N;
  while (M > Integer.MAX_VALUE) {
    dt = dt.withPeriodAdded(period, Integer.MAX_VALUE);
    M = M - Integer.MAX_VALUE;
  }
  while (M < Integer.MIN_VALUE) {
    dt = dt.withPeriodAdded(period, Integer.MIN_VALUE);
    M = M - Integer.MIN_VALUE;
  }
  dt = dt.withPeriodAdded(period, Math.toIntExact(M));

  // check if offset should be positive of negative
  if (period.toPeriod().getSeconds() < 0) {
    offset = -offset;
  }

  long ts = dt.getMillis() * Constants.TIME_UNITS_PER_MS;
  ts += instant % Constants.TIME_UNITS_PER_MS;
  ts += offset * N;

  return ts;
}
 

void setFieldValue(ReadWritablePeriod period, int field, int value) {
    switch (field) {
    default:
        break;
    case YEARS:
        period.setYears(value);
        break;
    case MONTHS:
        period.setMonths(value);
        break;
    case WEEKS:
        period.setWeeks(value);
        break;
    case DAYS:
        period.setDays(value);
        break;
    case HOURS:
        period.setHours(value);
        break;
    case MINUTES:
        period.setMinutes(value);
        break;
    case SECONDS:
        period.setSeconds(value);
        break;
    case MILLIS:
        period.setMillis(value);
        break;
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    if (periodStr.regionMatches(true, position, iText, 0, iText.length())) {
        return position + iText.length();
    }
    return ~position;
}
 

/**
 * Extracts duration values from an object of this converter's type, and
 * sets them into the given ReadWritableDuration.
 *
 * @param period  period to get modified
 * @param object  the String to convert, must not be null
 * @param chrono  the chronology to use
 * @return the millisecond duration
 * @throws ClassCastException if the object is invalid
 */
public void setInto(ReadWritablePeriod period, Object object, Chronology chrono) {
    String str = (String) object;
    PeriodFormatter parser = ISOPeriodFormat.standard();
    period.clear();
    int pos = parser.parseInto(period, str, 0);
    if (pos < str.length()) {
        if (pos < 0) {
            // Parse again to get a better exception thrown.
            parser.withParseType(period.getPeriodType()).parseMutablePeriod(str);
        }
        throw new IllegalArgumentException("Invalid format: \"" + str + '"');
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    PeriodParser[] parsers = iParsers;
    if (parsers == null) {
        throw new UnsupportedOperationException();
    }

    int len = parsers.length;
    for (int i=0; i<len && position >= 0; i++) {
        position = parsers[i].parseInto(period, periodStr, position, locale);
    }
    return position;
}
 

void setFieldValue(ReadWritablePeriod period, int field, int value) {
    switch (field) {
    default:
        break;
    case YEARS:
        period.setYears(value);
        break;
    case MONTHS:
        period.setMonths(value);
        break;
    case WEEKS:
        period.setWeeks(value);
        break;
    case DAYS:
        period.setDays(value);
        break;
    case HOURS:
        period.setHours(value);
        break;
    case MINUTES:
        period.setMinutes(value);
        break;
    case SECONDS:
        period.setSeconds(value);
        break;
    case MILLIS:
        period.setMillis(value);
        break;
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    if (periodStr.regionMatches(true, position, iText, 0, iText.length())) {
        return position + iText.length();
    }
    return ~position;
}
 

/**
 * Sets the values of the mutable duration from the specified interval.
 * 
 * @param writablePeriod  the period to modify
 * @param object  the interval to set from
 * @param chrono  the chronology to use
 */
public void setInto(ReadWritablePeriod writablePeriod, Object object, Chronology chrono) {
    ReadableInterval interval = (ReadableInterval) object;
    chrono = (chrono != null ? chrono : DateTimeUtils.getIntervalChronology(interval));
    long start = interval.getStartMillis();
    long end = interval.getEndMillis();
    int[] values = chrono.get(writablePeriod, start, end);
    for (int i = 0; i < values.length; i++) {
        writablePeriod.setValue(i, values[i]);
    }
}
 

public int parseInto(
        ReadWritablePeriod period, String periodStr,
        int position, Locale locale) {
    PeriodParser[] parsers = iParsers;
    if (parsers == null) {
        throw new UnsupportedOperationException();
    }

    int len = parsers.length;
    for (int i=0; i<len && position >= 0; i++) {
        position = parsers[i].parseInto(period, periodStr, position, locale);
    }
    return position;
}