Java Joda.forPattern方法代码示例

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
/**
 * Read from a stream.
 */
public RangeQueryBuilder(StreamInput in) throws IOException {
    super(in);
    fieldName = in.readString();
    from = in.readGenericValue();
    to = in.readGenericValue();
    includeLower = in.readBoolean();
    includeUpper = in.readBoolean();
    timeZone = in.readOptionalTimeZone();
    String formatString = in.readOptionalString();
    if (formatString != null) {
        format = Joda.forPattern(formatString);
    }
    if (in.getVersion().onOrAfter(Version.V_5_2_0_UNRELEASED)) {
        String relationString = in.readOptionalString();
        if (relationString != null) {
            relation = ShapeRelation.getRelationByName(relationString);
        }
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public void testThatEpochParserIsIdempotent() {
    FormatDateTimeFormatter formatter = Joda.forPattern("epoch_millis");
    DateTime dateTime = formatter.parser().parseDateTime("1234567890123");
    assertThat(dateTime.getMillis(), is(1234567890123L));
    dateTime = formatter.printer().parseDateTime("1234567890456");
    assertThat(dateTime.getMillis(), is(1234567890456L));
    dateTime = formatter.parser().parseDateTime("1234567890789");
    assertThat(dateTime.getMillis(), is(1234567890789L));
    dateTime = formatter.parser().parseDateTime("1234567890123456789");
    assertThat(dateTime.getMillis(), is(1234567890123456789L));

    FormatDateTimeFormatter secondsFormatter = Joda.forPattern("epoch_second");
    DateTime secondsDateTime = secondsFormatter.parser().parseDateTime("1234567890");
    assertThat(secondsDateTime.getMillis(), is(1234567890000L));
    secondsDateTime = secondsFormatter.printer().parseDateTime("1234567890");
    assertThat(secondsDateTime.getMillis(), is(1234567890000L));
    secondsDateTime = secondsFormatter.parser().parseDateTime("1234567890");
    assertThat(secondsDateTime.getMillis(), is(1234567890000L));
    secondsDateTime = secondsFormatter.parser().parseDateTime("1234567890123456");
    assertThat(secondsDateTime.getMillis(), is(1234567890123456000L));
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
@Override
public DocValueFormat docValueFormat(@Nullable String format, DateTimeZone timeZone) {
    FormatDateTimeFormatter dateTimeFormatter = this.dateTimeFormatter;
    if (format != null) {
        dateTimeFormatter = Joda.forPattern(format);
    }
    if (timeZone == null) {
        timeZone = DateTimeZone.UTC;
    }
    return new DocValueFormat.DateTime(dateTimeFormatter, timeZone);
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
@Override
public java.lang.Long valueOf(String value, String fmt) {
    FormatDateTimeFormatter f = formatter;
    if (fmt != null) {
        f = Joda.forPattern(fmt);
    }
    return f.parser().parseDateTime(value).getMillis();
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public Timestamp(boolean enabled, String path, String format, String defaultTimestamp, Boolean ignoreMissing) {
    this.enabled = enabled;
    this.path = path;
    if (path == null) {
        pathElements = Strings.EMPTY_ARRAY;
    } else {
        pathElements = Strings.delimitedListToStringArray(path, ".");
    }
    this.format = format;
    this.dateTimeFormatter = Joda.forPattern(format);
    this.defaultTimestamp = defaultTimestamp;
    this.ignoreMissing = ignoreMissing;
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
@Override
protected java.lang.Long valueOf(String value, String optionalFormat) {
    FormatDateTimeFormatter dateFormatter = this.dateFormatter;
    if (optionalFormat != null) {
        dateFormatter = Joda.forPattern(optionalFormat);
    }
    return dateFormatter.parser().parseMillis(value);
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public void testSlashInFormat() {
    FormatDateTimeFormatter formatter = Joda.forPattern("MM/yyyy");
    formatter.parser().parseMillis("01/2001");

    formatter = Joda.forPattern("yyyy/MM/dd HH:mm:ss");
    long millis = formatter.parser().parseMillis("1970/01/01 00:00:00");
    formatter.printer().print(millis);

    try {
        millis = formatter.parser().parseMillis("1970/01/01");
        fail();
    } catch (IllegalArgumentException e) {
        // it really can't parse this one
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
private void expectInvalidPattern(String pattern, String errorMessage) {
    try {
        Joda.forPattern(pattern);
        fail("Pattern " + pattern + " should have thrown an exception but did not");
    } catch (IllegalArgumentException e) {
        assertThat(e.getMessage(), containsString(errorMessage));
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public void testThatNegativeEpochsCanBeParsed() {
    // problem: negative epochs can be arbitrary in size...
    boolean parseMilliSeconds = randomBoolean();
    FormatDateTimeFormatter formatter = Joda.forPattern(parseMilliSeconds ? "epoch_millis" : "epoch_second");
    DateTime dateTime = formatter.parser().parseDateTime("-10000");

    assertThat(dateTime.getYear(), is(1969));
    assertThat(dateTime.getMonthOfYear(), is(12));
    assertThat(dateTime.getDayOfMonth(), is(31));
    if (parseMilliSeconds) {
        assertThat(dateTime.getHourOfDay(), is(23)); // utc timezone, +2 offset due to CEST
        assertThat(dateTime.getMinuteOfHour(), is(59));
        assertThat(dateTime.getSecondOfMinute(), is(50));
    } else {
        assertThat(dateTime.getHourOfDay(), is(21)); // utc timezone, +2 offset due to CEST
        assertThat(dateTime.getMinuteOfHour(), is(13));
        assertThat(dateTime.getSecondOfMinute(), is(20));
    }

    // every negative epoch must be parsed, no matter if exact the size or bigger
    if (parseMilliSeconds) {
        formatter.parser().parseDateTime("-100000000");
        formatter.parser().parseDateTime("-999999999999");
        formatter.parser().parseDateTime("-1234567890123");
        formatter.parser().parseDateTime("-1234567890123456789");
    } else {
        formatter.parser().parseDateTime("-100000000");
        formatter.parser().parseDateTime("-1234567890");
        formatter.parser().parseDateTime("-1234567890123456");
    }
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public void testThatEpochParserIsPrinter() {
    FormatDateTimeFormatter formatter = Joda.forPattern("epoch_millis");
    assertThat(formatter.parser().isPrinter(), is(true));
    assertThat(formatter.printer().isPrinter(), is(true));

    FormatDateTimeFormatter epochSecondFormatter = Joda.forPattern("epoch_second");
    assertThat(epochSecondFormatter.parser().isPrinter(), is(true));
    assertThat(epochSecondFormatter.printer().isPrinter(), is(true));
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public DateTime(StreamInput in) throws IOException {
    this(Joda.forPattern(in.readString()), DateTimeZone.forID(in.readString()));
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public static FormatDateTimeFormatter parseDateTimeFormatter(Object node) {
    return Joda.forPattern(node.toString());
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    super.readFrom(in);
    dateFormatter =  Joda.forPattern(in.readString());
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    formatter = Joda.forPattern(in.readString());
    timeZone = DateTimeZone.forID(in.readString());
}
 

import org.elasticsearch.common.joda.Joda; //导入方法依赖的package包/类
public DateTime(String format, DateTimeZone timezone) {
    this.formatter = Joda.forPattern(format);
    this.timeZone = timezone != null ? timezone : DateTimeZone.UTC;
}