org.joda.time.convert.StringConverter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of swagger-all Show documentation
Show all versions of swagger-all Show documentation
swagger-all is a rebundled verison of Swagger as one OSGi bundle.
/*
* Copyright 2001-2009 Stephen Colebourne
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.joda.time.convert;
import org.joda.time.Chronology;
import org.joda.time.DateTime;
import org.joda.time.Period;
import org.joda.time.ReadWritableInterval;
import org.joda.time.ReadWritablePeriod;
import org.joda.time.ReadablePartial;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;
import org.joda.time.format.ISOPeriodFormat;
import org.joda.time.format.PeriodFormatter;
/**
* StringConverter converts from a String to an instant, partial,
* duration, period or interval..
*
* @author Stephen Colebourne
* @author Brian S O'Neill
* @since 1.0
*/
class StringConverter extends AbstractConverter
implements InstantConverter, PartialConverter, DurationConverter, PeriodConverter, IntervalConverter {
/**
* Singleton instance.
*/
static final StringConverter INSTANCE = new StringConverter();
/**
* Restricted constructor.
*/
protected StringConverter() {
super();
}
//-----------------------------------------------------------------------
/**
* Gets the millis, which is the ISO parsed string value.
*
* @param object the String to convert, must not be null
* @param chrono the chronology to use, non-null result of getChronology
* @return the millisecond value
* @throws IllegalArgumentException if the value if invalid
*/
public long getInstantMillis(Object object, Chronology chrono) {
String str = (String) object;
DateTimeFormatter p = ISODateTimeFormat.dateTimeParser();
return p.withChronology(chrono).parseMillis(str);
}
/**
* Extracts the values of the partial from an object of this converter's type.
* This method checks if the parser has a zone, and uses it if present.
* This is most useful for parsing local times with UTC.
*
* @param fieldSource a partial that provides access to the fields.
* This partial may be incomplete and only getFieldType(int) should be used
* @param object the object to convert
* @param chrono the chronology to use, which is the non-null result of getChronology()
* @param parser the parser to use, may be null
* @return the array of field values that match the fieldSource, must be non-null valid
* @throws ClassCastException if the object is invalid
* @throws IllegalArgumentException if the value if invalid
* @since 1.3
*/
public int[] getPartialValues(ReadablePartial fieldSource, Object object, Chronology chrono, DateTimeFormatter parser) {
if (parser.getZone() != null) {
chrono = chrono.withZone(parser.getZone());
}
long millis = parser.withChronology(chrono).parseMillis((String) object);
return chrono.get(fieldSource, millis);
}
//-----------------------------------------------------------------------
/**
* Gets the duration of the string using the standard type.
* This matches the toString() method of ReadableDuration.
*
* @param object the String to convert, must not be null
* @throws ClassCastException if the object is invalid
*/
public long getDurationMillis(Object object) {
// parse here because duration could be bigger than the int supported
// by the period parser
String original = (String) object;
String str = original;
int len = str.length();
if (len >= 4 &&
(str.charAt(0) == 'P' || str.charAt(0) == 'p') &&
(str.charAt(1) == 'T' || str.charAt(1) == 't') &&
(str.charAt(len - 1) == 'S' || str.charAt(len - 1) == 's')) {
// ok
} else {
throw new IllegalArgumentException("Invalid format: \"" + original + '"');
}
str = str.substring(2, len - 1);
int dot = -1;
boolean negative = false;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
// ok
} else if (i == 0 && str.charAt(0) == '-') {
// ok
negative = true;
} else if (i > (negative ? 1 : 0) && str.charAt(i) == '.' && dot == -1) {
// ok
dot = i;
} else {
throw new IllegalArgumentException("Invalid format: \"" + original + '"');
}
}
long millis = 0, seconds = 0;
int firstDigit = negative ? 1 : 0;
if (dot > 0) {
seconds = Long.parseLong(str.substring(firstDigit, dot));
str = str.substring(dot + 1);
if (str.length() != 3) {
str = (str + "000").substring(0, 3);
}
millis = Integer.parseInt(str);
} else if (negative) {
seconds = Long.parseLong(str.substring(firstDigit, str.length()));
} else {
seconds = Long.parseLong(str);
}
if (negative) {
return FieldUtils.safeAdd(FieldUtils.safeMultiply(-seconds, 1000), -millis);
} else {
return FieldUtils.safeAdd(FieldUtils.safeMultiply(seconds, 1000), millis);
}
}
//-----------------------------------------------------------------------
/**
* 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 value of the mutable interval from the string.
*
* @param writableInterval the interval to set
* @param object the String to convert, must not be null
* @param chrono the chronology to use, may be null
*/
public void setInto(ReadWritableInterval writableInterval, Object object, Chronology chrono) {
String str = (String) object;
int separator = str.indexOf('/');
if (separator < 0) {
throw new IllegalArgumentException("Format requires a '/' separator: " + str);
}
String leftStr = str.substring(0, separator);
if (leftStr.length() <= 0) {
throw new IllegalArgumentException("Format invalid: " + str);
}
String rightStr = str.substring(separator + 1);
if (rightStr.length() <= 0) {
throw new IllegalArgumentException("Format invalid: " + str);
}
DateTimeFormatter dateTimeParser = ISODateTimeFormat.dateTimeParser();
dateTimeParser = dateTimeParser.withChronology(chrono);
PeriodFormatter periodParser = ISOPeriodFormat.standard();
long startInstant = 0, endInstant = 0;
Period period = null;
Chronology parsedChrono = null;
// before slash
char c = leftStr.charAt(0);
if (c == 'P' || c == 'p') {
period = periodParser.withParseType(getPeriodType(leftStr)).parsePeriod(leftStr);
} else {
DateTime start = dateTimeParser.parseDateTime(leftStr);
startInstant = start.getMillis();
parsedChrono = start.getChronology();
}
// after slash
c = rightStr.charAt(0);
if (c == 'P' || c == 'p') {
if (period != null) {
throw new IllegalArgumentException("Interval composed of two durations: " + str);
}
period = periodParser.withParseType(getPeriodType(rightStr)).parsePeriod(rightStr);
chrono = (chrono != null ? chrono : parsedChrono);
endInstant = chrono.add(period, startInstant, 1);
} else {
DateTime end = dateTimeParser.parseDateTime(rightStr);
endInstant = end.getMillis();
parsedChrono = (parsedChrono != null ? parsedChrono : end.getChronology());
chrono = (chrono != null ? chrono : parsedChrono);
if (period != null) {
startInstant = chrono.add(period, endInstant, -1);
}
}
writableInterval.setInterval(startInstant, endInstant);
writableInterval.setChronology(chrono);
}
//-----------------------------------------------------------------------
/**
* Returns String.class.
*
* @return String.class
*/
public Class getSupportedType() {
return String.class;
}
}