Java Code Examples for org.joda.time.ReadWritableInstant#getMillis()
The following examples show how to use
org.joda.time.ReadWritableInstant#getMillis() .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: 1_DateTimeFormatter.java From SimFix with GNU General Public License v2.0 | 5 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant based on the chronology * and time-zone of the supplied instant. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); // start of generated patch long instantLocal=instantMillis+chrono.getZone().getOffset(instantMillis); chrono=selectChronology(chrono); int defaultYear=chrono.year().get(instantMillis); // end of generated patch /* start of original code long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); int defaultYear = chrono.year().get(instantLocal); end of original code*/ DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, defaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 2
Source File: Cardumen_0073_s.java From coming with MIT License | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant based on the chronology * and time-zone of the supplied instant. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); int defaultYear = chrono.year().get(instantLocal); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, defaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 3
Source File: Cardumen_0073_t.java From coming with MIT License | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant based on the chronology * and time-zone of the supplied instant. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); int defaultYear = chrono.year().get(instantMillis); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, defaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 4
Source File: Time_16_DateTimeFormatter_s.java From coming with MIT License | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant as the default. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, iDefaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 5
Source File: Time_16_DateTimeFormatter_t.java From coming with MIT License | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant as the default. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, chrono.year().get(instantLocal)); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 6
Source File: Time_7_DateTimeFormatter_s.java From coming with MIT License | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant based on the chronology * and time-zone of the supplied instant. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); int defaultYear = chrono.year().get(instantLocal); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, defaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 7
Source File: Time_7_DateTimeFormatter_t.java From coming with MIT License | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant based on the chronology * and time-zone of the supplied instant. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); int defaultYear = DateTimeUtils.getChronology(chrono).year().get(instantMillis); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, defaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 8
Source File: DateTimeFormatter.java From astor with GNU General Public License v2.0 | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant based on the chronology * and time-zone of the supplied instant. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); int defaultYear = DateTimeUtils.getChronology(chrono).year().get(instantMillis); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, defaultYear); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }
Example 9
Source File: DateTimeFormatter.java From astor with GNU General Public License v2.0 | 3 votes |
/** * Parses a datetime from the given text, at the given position, saving the * result into the fields of the given ReadWritableInstant. If the parse * succeeds, the return value is the new text position. Note that the parse * may succeed without fully reading the text and in this case those fields * that were read will be set. * <p> * Only those fields present in the string will be changed in the specified * instant. All other fields will remain unaltered. Thus if the string only * contains a year and a month, then the day and time will be retained from * the input instant. If this is not the behaviour you want, then reset the * fields before calling this method, or use {@link #parseDateTime(String)} * or {@link #parseMutableDateTime(String)}. * <p> * If it fails, the return value is negative, but the instant may still be * modified. To determine the position where the parse failed, apply the * one's complement operator (~) on the return value. * <p> * This parse method ignores the {@link #getDefaultYear() default year} and * parses using the year from the supplied instant as the default. * <p> * The parse will use the chronology of the instant. * * @param instant an instant that will be modified, not null * @param text the text to parse * @param position position to start parsing from * @return new position, negative value means parse failed - * apply complement operator (~) to get position of failure * @throws UnsupportedOperationException if parsing is not supported * @throws IllegalArgumentException if the instant is null * @throws IllegalArgumentException if any field is out of range */ public int parseInto(ReadWritableInstant instant, String text, int position) { DateTimeParser parser = requireParser(); if (instant == null) { throw new IllegalArgumentException("Instant must not be null"); } long instantMillis = instant.getMillis(); Chronology chrono = instant.getChronology(); long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis); chrono = selectChronology(chrono); DateTimeParserBucket bucket = new DateTimeParserBucket( instantLocal, chrono, iLocale, iPivotYear, chrono.year().get(instantLocal)); int newPos = parser.parseInto(bucket, text, position); instant.setMillis(bucket.computeMillis(false, text)); if (iOffsetParsed && bucket.getOffsetInteger() != null) { int parsedOffset = bucket.getOffsetInteger(); DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset); chrono = chrono.withZone(parsedZone); } else if (bucket.getZone() != null) { chrono = chrono.withZone(bucket.getZone()); } instant.setChronology(chrono); if (iZone != null) { instant.setZone(iZone); } return newPos; }