Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    *  Copyright 2001-2009 Stephen Colebourne
3
    *
4
    *  Licensed under the Apache License, Version 2.0 (the "License");
5
    *  you may not use this file except in compliance with the License.
6
    *  You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   *  Unless required by applicable law or agreed to in writing, software
11
   *  distributed under the License is distributed on an "AS IS" BASIS,
12
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   *  See the License for the specific language governing permissions and
14
   *  limitations under the License.
15
   */
16
  package org.joda.time.format;
17
  
19
  import java.io.Writer;
22
  import java.util.List;
23
  import java.util.Locale;
24
  import java.util.TreeSet;
25
  
Factory that creates complex instances of PeriodFormatter via method calls.

Period formatting is performed by the PeriodFormatter class. Three classes provide factory methods to create formatters, and this is one. The others are PeriodFormat and ISOPeriodFormat.

PeriodFormatterBuilder is used for constructing formatters which are then used to print or parse. The formatters are built by appending specific fields or other formatters to an instance of this builder.

For example, a formatter that prints years and months, like "15 years and 8 months", can be constructed as follows: 

 PeriodFormatter yearsAndMonths = new PeriodFormatterBuilder()
     .printZeroAlways()
     .appendYears()
     .appendSuffix(" year", " years")
     .appendSeparator(" and ")
     .printZeroRarelyLast()
     .appendMonths()
     .appendSuffix(" month", " months")
     .toFormatter();

PeriodFormatterBuilder itself is mutable and not thread-safe, but the formatters that it builds are thread-safe and immutable.

Author(s):
Brian S O'Neill
Since:
1.0
See also:
PeriodFormat
64
  
65
  public class PeriodFormatterBuilder {
66
      private static final int PRINT_ZERO_RARELY_FIRST = 1;
67
      private static final int PRINT_ZERO_RARELY_LAST = 2;
68
      private static final int PRINT_ZERO_IF_SUPPORTED = 3;
69
      private static final int PRINT_ZERO_ALWAYS = 4;
70
      private static final int PRINT_ZERO_NEVER = 5;
71
      
72
      private static final int YEARS = 0;
73
      private static final int MONTHS = 1;
74
      private static final int WEEKS = 2;
75
      private static final int DAYS = 3;
76
      private static final int HOURS = 4;
77
      private static final int MINUTES = 5;
78
      private static final int SECONDS = 6;
79
      private static final int MILLIS = 7;
80
      private static final int SECONDS_MILLIS = 8;
81
      private static final int SECONDS_OPTIONAL_MILLIS = 9;
82
      private static final int MAX_FIELD = ;
83
  
84
      private int iMinPrintedDigits;
85
      private int iPrintZeroSetting;
86
      private int iMaxParsedDigits;
87
      private boolean iRejectSignedValues;
88
  
89
      private PeriodFieldAffix iPrefix;
90
  
91
      // List of Printers and Parsers used to build a final formatter.
92
      private List<Object> iElementPairs;
    
Set to true if the formatter is not a printer.
93
  
94
      private boolean iNotPrinter;
    
Set to true if the formatter is not a parser.
95
  
96
      private boolean iNotParser;
97
  
98
      // Last PeriodFormatter appended of each field type.
99
      private FieldFormatter[] iFieldFormatters;
100
 
101
     public PeriodFormatterBuilder() {
102
         clear();
103
     }
104
 
105
     //-----------------------------------------------------------------------
106
     
Constructs a PeriodFormatter using all the appended elements.

This is the main method used by applications at the end of the build process to create a usable formatter.

Subsequent changes to this builder do not affect the returned formatter.

The returned formatter may not support both printing and parsing. The methods PeriodFormatter.isPrinter() and PeriodFormatter.isParser() will help you determine the state of the formatter.

Returns:
the newly created formatter
Throws:
java.lang.IllegalStateException if the builder can produce neither a printer nor a parser
121
 
122
     public PeriodFormatter toFormatter() {
123
         PeriodFormatter formatter = toFormatter(, , );
125
         return formatter;
126
     }

    
Internal method to create a PeriodPrinter instance using all the appended elements.

Most applications will not use this method. If you want a printer in an application, call toFormatter() and just use the printing API.

Subsequent changes to this builder do not affect the returned printer.

Returns:
the newly created printer, null if builder cannot create a printer
139
 
140
     public PeriodPrinter toPrinter() {
141
         if () {
142
             return null;
143
         }
144
         return toFormatter().getPrinter();
145
     }

    
Internal method to create a PeriodParser instance using all the appended elements.

Most applications will not use this method. If you want a printer in an application, call toFormatter() and just use the printing API.

Subsequent changes to this builder do not affect the returned parser.

Returns:
the newly created parser, null if builder cannot create a parser
158
 
159
     public PeriodParser toParser() {
160
         if () {
161
             return null;
162
         }
163
         return toFormatter().getParser();
164
     }
165
 
166
     //-----------------------------------------------------------------------
167
     
Clears out all the appended elements, allowing this builder to be reused. 
169
 
170
     public void clear() {
171
          = 1;
173
          = 10;
174
          = false;
175
          = null;
176
         if ( == null) {
177
              = new ArrayList<Object>();
178
         } else {
179
             .clear();
180
         }
181
          = false;
182
          = false;
183
          = new FieldFormatter[10];
184
     }

    
Appends another formatter.

Returns:
this PeriodFormatterBuilder
190
 
191
     public PeriodFormatterBuilder append(PeriodFormatter formatter) {
192
         if (formatter == null) {
193
             throw new IllegalArgumentException("No formatter supplied");
194
         }
195
         clearPrefix();
196
         append0(formatter.getPrinter(), formatter.getParser());
197
         return this;
198
     }

    
Appends a printer parser pair.

Either the printer or the parser may be null, in which case the builder will be unable to produce a parser or printer repectively.

Parameters:
printer appends a printer to the builder, null if printing is not supported
parser appends a parser to the builder, null if parsing is not supported
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalArgumentException if both the printer and parser are null
210
 
211
     public PeriodFormatterBuilder append(PeriodPrinter printer, PeriodParser parser) {
212
         if (printer == null && parser == null) {
213
             throw new IllegalArgumentException("No printer or parser supplied");
214
         }
215
         clearPrefix();
216
         append0(printer, parser);
217
         return this;
218
     }

    
Instructs the printer to emit specific text, and the parser to expect it. The parser is case-insensitive.

Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalArgumentException if text is null
226
 
227
     public PeriodFormatterBuilder appendLiteral(String text) {
228
         if (text == null) {
229
             throw new IllegalArgumentException("Literal must not be null");
230
         }
231
         clearPrefix();
232
         Literal literal = new Literal(text);
233
         append0(literal, literal);
234
         return this;
235
     }

    
Set the minimum digits printed for the next and following appended fields. By default, the minimum digits printed is one. If the field value is zero, it is not printed unless a printZero rule is applied.

Returns:
this PeriodFormatterBuilder
243
 
244
     public PeriodFormatterBuilder minimumPrintedDigits(int minDigits) {
245
          = minDigits;
246
         return this;
247
     }

    
Set the maximum digits parsed for the next and following appended fields. By default, the maximum digits parsed is ten.

Returns:
this PeriodFormatterBuilder
254
 
255
     public PeriodFormatterBuilder maximumParsedDigits(int maxDigits) {
256
          = maxDigits;
257
         return this;
258
     }

    
Reject signed values when parsing the next and following appended fields.

Returns:
this PeriodFormatterBuilder
264
 
265
     public PeriodFormatterBuilder rejectSignedValues(boolean v) {
266
          = v;
267
         return this;
268
     }

    
Never print zero values for the next and following appended fields, unless no fields would be printed. If no fields are printed, the printer forces the last "printZeroRarely" field to print a zero.

This field setting is the default.

Returns:
this PeriodFormatterBuilder
278
 
281
         return this;
282
     }

    
Never print zero values for the next and following appended fields, unless no fields would be printed. If no fields are printed, the printer forces the first "printZeroRarely" field to print a zero.

Returns:
this PeriodFormatterBuilder
290
 
293
         return this;
294
     }

    
Print zero values for the next and following appened fields only if the period supports it.

Returns:
this PeriodFormatterBuilder
301
 
304
         return this;
305
     }

    
Always print zero values for the next and following appended fields, even if the period doesn't support it. The parser requires values for fields that always print zero.

Returns:
this PeriodFormatterBuilder
313
 
316
         return this;
317
     }

    
Never print zero values for the next and following appended fields, unless no fields would be printed. If no fields are printed, the printer forces the last "printZeroRarely" field to print a zero.

This field setting is the default.

Returns:
this PeriodFormatterBuilder
327
 
329
          = ;
330
         return this;
331
     }
332
 
333
     //-----------------------------------------------------------------------
334
     
Append a field prefix which applies only to the next appended field. If the field is not printed, neither is the prefix.

Parameters:
text text to print before field only if field is printed
Returns:
this PeriodFormatterBuilder
See also:
appendSuffix(java.lang.String)
341
 
342
     public PeriodFormatterBuilder appendPrefix(String text) {
343
         if (text == null) {
344
             throw new IllegalArgumentException();
345
         }
346
         return appendPrefix(new SimpleAffix(text));
347
     }

    
Append a field prefix which applies only to the next appended field. If the field is not printed, neither is the prefix.

During parsing, the singular and plural versions are accepted whether or not the actual value matches plurality.

Parameters:
singularText text to print if field value is one
pluralText text to print if field value is not one
Returns:
this PeriodFormatterBuilder
See also:
appendSuffix(java.lang.String)
360
 
361
     public PeriodFormatterBuilder appendPrefix(String singularText,
362
                                                  String pluralText) {
363
         if (singularText == null || pluralText == null) {
364
             throw new IllegalArgumentException();
365
         }
366
         return appendPrefix(new PluralAffix(singularText, pluralText));
367
     }

    
Append a field prefix which applies only to the next appended field. If the field is not printed, neither is the prefix.

Parameters:
prefix custom prefix
Returns:
this PeriodFormatterBuilder
See also:
appendSuffix(java.lang.String)
376
 
378
         if (prefix == null) {
379
             throw new IllegalArgumentException();
380
         }
381
         if ( != null) {
382
             prefix = new CompositeAffix(, prefix);
383
         }
384
          = prefix;
385
         return this;
386
     }
387
 
388
     //-----------------------------------------------------------------------
389
     
Instruct the printer to emit an integer years field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
396
 
397
     public PeriodFormatterBuilder appendYears() {
398
         appendField();
399
         return this;
400
     }

    
Instruct the printer to emit an integer months field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
409
 
410
     public PeriodFormatterBuilder appendMonths() {
411
         appendField();
412
         return this;
413
     }

    
Instruct the printer to emit an integer weeks field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
422
 
423
     public PeriodFormatterBuilder appendWeeks() {
424
         appendField();
425
         return this;
426
     }

    
Instruct the printer to emit an integer days field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
435
 
436
     public PeriodFormatterBuilder appendDays() {
437
         appendField();
438
         return this;
439
     }

    
Instruct the printer to emit an integer hours field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
448
 
449
     public PeriodFormatterBuilder appendHours() {
450
         appendField();
451
         return this;
452
     }

    
Instruct the printer to emit an integer minutes field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
461
 
463
         appendField();
464
         return this;
465
     }

    
Instruct the printer to emit an integer seconds field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
474
 
476
         appendField();
477
         return this;
478
     }

    
Instruct the printer to emit a combined seconds and millis field, if supported. The millis will overflow into the seconds if necessary. The millis are always output.

Returns:
this PeriodFormatterBuilder
486
 
488
         appendField();
489
         return this;
490
     }

    
Instruct the printer to emit a combined seconds and millis field, if supported. The millis will overflow into the seconds if necessary. The millis are only output if non-zero.

Returns:
this PeriodFormatterBuilder
498
 
501
         return this;
502
     }

    
Instruct the printer to emit an integer millis field, if supported.

The number of printed and parsed digits can be controlled using minimumPrintedDigits(int) and maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
511
 
512
     public PeriodFormatterBuilder appendMillis() {
513
         appendField();
514
         return this;
515
     }

    
Instruct the printer to emit an integer millis field, if supported.

The number of arsed digits can be controlled using maximumParsedDigits(int).

Returns:
this PeriodFormatterBuilder
523
 
525
         appendField(7, 3);
526
         return this;
527
     }
528
 
529
     private void appendField(int type) {
530
         appendField(type, );
531
     }
532
 
533
     private void appendField(int type, int minPrinted) {
534
         FieldFormatter field = new FieldFormatter(minPrinted, ,
535
             , , type, , , null);
536
         append0(field, field);
537
         [type] = field;
538
          = null;
539
     }
540
 
541
     //-----------------------------------------------------------------------
542
     
Append a field suffix which applies only to the last appended field. If the field is not printed, neither is the suffix.

Parameters:
text text to print after field only if field is printed
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if no field exists to append to
See also:
appendPrefix(java.lang.String)
550
 
551
     public PeriodFormatterBuilder appendSuffix(String text) {
552
         if (text == null) {
553
             throw new IllegalArgumentException();
554
         }
555
         return appendSuffix(new SimpleAffix(text));
556
     }

    
Append a field suffix which applies only to the last appended field. If the field is not printed, neither is the suffix.

During parsing, the singular and plural versions are accepted whether or not the actual value matches plurality.

Parameters:
singularText text to print if field value is one
pluralText text to print if field value is not one
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if no field exists to append to
See also:
appendPrefix(java.lang.String)
570
 
571
     public PeriodFormatterBuilder appendSuffix(String singularText,
572
                                                String pluralText) {
573
         if (singularText == null || pluralText == null) {
574
             throw new IllegalArgumentException();
575
         }
576
         return appendSuffix(new PluralAffix(singularText, pluralText));
577
     }

    
Append a field suffix which applies only to the last appended field. If the field is not printed, neither is the suffix.

Parameters:
suffix custom suffix
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if no field exists to append to
See also:
appendPrefix(java.lang.String)
587
 
589
         final Object originalPrinter;
590
         final Object originalParser;
591
         if (.size() > 0) {
592
             originalPrinter = .get(.size() - 2);
593
             originalParser = .get(.size() - 1);
594
         } else {
595
             originalPrinter = null;
596
             originalParser = null;
597
         }
598
 
599
         if (originalPrinter == null || originalParser == null ||
600
                 originalPrinter != originalParser ||
601
                 !(originalPrinter instanceof FieldFormatter)) {
602
             throw new IllegalStateException("No field to apply suffix to");
603
         }
604
 
605
         clearPrefix();
606
         FieldFormatter newField = new FieldFormatter((FieldFormatter) originalPrinter, suffix);
607
         .set(.size() - 2, newField);
608
         .set(.size() - 1, newField);
609
         [newField.getFieldType()] = newField;
610
         
611
         return this;
612
     }
613
 
614
     //-----------------------------------------------------------------------
615
     
Append a separator, which is output if fields are printed both before and after the separator.

For example, builder.appendDays().appendSeparator(",").appendHours() will only output the comma if both the days and hours fields are output.

The text will be parsed case-insensitively.

Note: appending a separator discontinues any further work on the latest appended field.

Parameters:
text the text to use as a separator
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if this separator follows a previous one
630
 
631
     public PeriodFormatterBuilder appendSeparator(String text) {
632
         return appendSeparator(text, text, null, true, true);
633
     }

    
Append a separator, which is output only if fields are printed after the separator.

For example, builder.appendDays().appendSeparatorIfFieldsAfter(",").appendHours() will only output the comma if the hours fields is output.

The text will be parsed case-insensitively.

Note: appending a separator discontinues any further work on the latest appended field.

Parameters:
text the text to use as a separator
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if this separator follows a previous one
650
 
652
         return appendSeparator(text, text, null, false, true);
653
     }

    
Append a separator, which is output only if fields are printed before the separator.

For example, builder.appendDays().appendSeparatorIfFieldsBefore(",").appendHours() will only output the comma if the days fields is output.

The text will be parsed case-insensitively.

Note: appending a separator discontinues any further work on the latest appended field.

Parameters:
text the text to use as a separator
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if this separator follows a previous one
670
 
672
         return appendSeparator(text, text, null, true, false);
673
     }

    
Append a separator, which is output if fields are printed both before and after the separator.

This method changes the separator depending on whether it is the last separator to be output.

For example, builder.appendDays().appendSeparator(",", "&").appendHours().appendSeparator(",", "&").appendMinutes() will output '1,2&3' if all three fields are output, '1&2' if two fields are output and '1' if just one field is output.

The text will be parsed case-insensitively.

Note: appending a separator discontinues any further work on the latest appended field.

Parameters:
text the text to use as a separator
finalText the text used used if this is the final separator to be printed
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if this separator follows a previous one
695
 
696
     public PeriodFormatterBuilder appendSeparator(String text, String finalText) {
697
         return appendSeparator(text, finalText, null, true, true);
698
     }

    
Append a separator, which is output if fields are printed both before and after the separator.

This method changes the separator depending on whether it is the last separator to be output.

For example, builder.appendDays().appendSeparator(",", "&").appendHours().appendSeparator(",", "&").appendMinutes() will output '1,2&3' if all three fields are output, '1&2' if two fields are output and '1' if just one field is output.

The text will be parsed case-insensitively.

Note: appending a separator discontinues any further work on the latest appended field.

Parameters:
text the text to use as a separator
finalText the text used used if this is the final separator to be printed
variants set of text values which are also acceptable when parsed
Returns:
this PeriodFormatterBuilder
Throws:
java.lang.IllegalStateException if this separator follows a previous one
721
 
722
     public PeriodFormatterBuilder appendSeparator(String text, String finalText,
723
                                                   String[] variants) {
724
         return appendSeparator(text, finalText, variants, true, true);
725
     }
726
 
727
     private PeriodFormatterBuilder appendSeparator(String text, String finalText,
728
                                                    String[] variants,
729
                                                    boolean useBefore, boolean useAfter) {
730
         if (text == null || finalText == null) {
731
             throw new IllegalArgumentException();
732
         }
733
 
734
         clearPrefix();
735
         
736
         // optimise zero formatter case
737
         List<Object> pairs = ;
738
         if (pairs.size() == 0) {
739
             if (useAfter && useBefore == false) {
740
                 Separator separator = new Separator(
741
                         text, finalText, variants,
742
                         ., ., useBefore, useAfter);
743
                 append0(separator, separator);
744
             }
745
             return this;
746
         }
747
         
748
         // find the last separator added
749
         int i;
750
         Separator lastSeparator = null;
751
         for (i=pairs.size(); --i>=0; ) {
752
             if (pairs.get(i) instanceof Separator) {
753
                 lastSeparator = (Separator) pairs.get(i);
754
                 pairs = pairs.subList(i + 1, pairs.size());
755
                 break;
756
             }
757
             i--;  // element pairs
758
         }
759
         
760
         // merge formatters
761
         if (lastSeparator != null && pairs.size() == 0) {
762
             throw new IllegalStateException("Cannot have two adjacent separators");
763
         } else {
764
             Object[] comp = createComposite(pairs);
765
             pairs.clear();
766
             Separator separator = new Separator(
767
                     text, finalText, variants,
768
                     (PeriodPrinter) comp[0], (PeriodParser) comp[1],
769
                     useBefore, useAfter);
770
             pairs.add(separator);
771
             pairs.add(separator);
772
         }
773
         
774
         return this;
775
     }
776
 
777
     //-----------------------------------------------------------------------
778
     private void clearPrefix() throws IllegalStateException {
779
         if ( != null) {
780
             throw new IllegalStateException("Prefix not followed by field");
781
         }
782
          = null;
783
     }
784
 
785
     private PeriodFormatterBuilder append0(PeriodPrinter printer, PeriodParser parser) {
786
         .add(printer);
787
         .add(parser);
788
          |= (printer == null);
789
          |= (parser == null);
790
         return this;
791
     }
792
 
793
     //-----------------------------------------------------------------------
794
     private static PeriodFormatter toFormatter(List<Object> elementPairs, boolean notPrinter, boolean notParser) {
795
         if (notPrinter && notParser) {
796
             throw new IllegalStateException("Builder has created neither a printer nor a parser");
797
         }
798
         int size = elementPairs.size();
799
         if (size >= 2 && elementPairs.get(0) instanceof Separator) {
800
             Separator sep = (Separator) elementPairs.get(0);
801
             if (sep.iAfterParser == null && sep.iAfterPrinter == null) {
802
                 PeriodFormatter f = toFormatter(elementPairs.subList(2, size), notPrinter, notParser);
803
                 sep = sep.finish(f.getPrinter(), f.getParser());
804
                 return new PeriodFormatter(sep, sep);
805
             }
806
         }
807
         Object[] comp = createComposite(elementPairs);
808
         if (notPrinter) {
809
             return new PeriodFormatter(null, (PeriodParser) comp[1]);
810
         } else if (notParser) {
811
             return new PeriodFormatter((PeriodPrinter) comp[0], null);
812
         } else {
813
             return new PeriodFormatter((PeriodPrinter) comp[0], (PeriodParser) comp[1]);
814
         }
815
     }
816
 
817
     private static Object[] createComposite(List<Object> elementPairs) {
818
         switch (elementPairs.size()) {
819
             case 0:
820
                 return new Object[] {., .};
821
             case 1:
822
                 return new Object[] {elementPairs.get(0), elementPairs.get(1)};
823
             default:
824
                 Composite comp = new Composite(elementPairs);
825
                 return new Object[] {comp, comp};
826
         }
827
     }
828
 
829
     //-----------------------------------------------------------------------
830
     
Defines a formatted field's prefix or suffix text. This can be used for fields such as 'n hours' or 'nH' or 'Hour:n'. 
833
 
834
     static interface PeriodFieldAffix {
835
         int calculatePrintedLength(int value);
836
         
837
         void printTo(StringBuffer buf, int value);
838
         
839
         void printTo(Writer out, int value) throws IOException;
        
        

Returns:
new position after parsing affix, or ~position of failure
843
 
844
         int parse(String periodStr, int position);

        

Returns:
position where affix starts, or original ~position if not found
848
 
849
         int scan(String periodStr, int position);
850
     }
851
 
852
     //-----------------------------------------------------------------------
853
     
Implements an affix where the text does not vary by the amount. 
855
 
856
     static class SimpleAffix implements PeriodFieldAffix {
857
         private final String iText;
858
 
859
         SimpleAffix(String text) {
860
              = text;
861
         }
862
 
863
         public int calculatePrintedLength(int value) {
864
             return .length();
865
         }
866
 
867
         public void printTo(StringBuffer buf, int value) {
868
             buf.append();
869
         }
870
 
871
         public void printTo(Writer out, int value) throws IOException {
872
             out.write();
873
         }
874
 
875
         public int parse(String periodStr, int position) {
876
             String text = ;
877
             int textLength = text.length();
878
             if (periodStr.regionMatches(true, position, text, 0, textLength)) {
879
                 return position + textLength;
880
             }
881
             return ~position;
882
         }
883
 
884
         public int scan(String periodStr, final int position) {
885
             String text = ;
886
             int textLength = text.length();
887
             int sourceLength = periodStr.length();
888
             search:
889
             for (int pos = position; pos < sourceLength; pos++) {
890
                 if (periodStr.regionMatches(true, pos, text, 0, textLength)) {
891
                     return pos;
892
                 }
893
                 // Only allow number characters to be skipped in search of suffix.
894
                 switch (periodStr.charAt(pos)) {
895
                 case '0': case '1': case '2': case '3': case '4':
896
                 case '5': case '6': case '7': case '8': case '9':
897
                 case '.': case ',': case '+': case '-':
898
                     break;
899
                 default:
900
                     break search;
901
                 }
902
             }
903
             return ~position;
904
         }
905
     }
906
 
907
     //-----------------------------------------------------------------------
908
     
Implements an affix where the text varies by the amount of the field. Only singular (1) and plural (not 1) are supported. 
911
 
912
     static class PluralAffix implements PeriodFieldAffix {
913
         private final String iSingularText;
914
         private final String iPluralText;
915
 
916
         PluralAffix(String singularText, String pluralText) {
917
              = singularText;
918
              = pluralText;
919
         }
920
 
921
         public int calculatePrintedLength(int value) {
922
             return (value == 1 ?  : ).length();
923
         }
924
 
925
         public void printTo(StringBuffer buf, int value) {
926
             buf.append(value == 1 ?  : );
927
         }
928
 
929
         public void printTo(Writer out, int value) throws IOException {
930
             out.write(value == 1 ?  : );
931
         }
932
 
933
         public int parse(String periodStr, int position) {
934
             String text1 = ;
935
             String text2 = ; 
936
 
937
             if (text1.length() < text2.length()) {
938
                 // Swap in order to match longer one first.
939
                 String temp = text1;
940
                 text1 = text2;
941
                 text2 = temp;
942
             }
943
 
944
             if (periodStr.regionMatches
945
                 (true, position, text1, 0, text1.length())) {
946
                 return position + text1.length();
947
             }
948
             if (periodStr.regionMatches
949
                 (true, position, text2, 0, text2.length())) {
950
                 return position + text2.length();
951
             }
952
 
953
             return ~position;
954
         }
955
 
956
         public int scan(String periodStr, final int position) {
957
             String text1 = ;
958
             String text2 = ; 
959
 
960
             if (text1.length() < text2.length()) {
961
                 // Swap in order to match longer one first.
962
                 String temp = text1;
963
                 text1 = text2;
964
                 text2 = temp;
965
             }
966
 
967
             int textLength1 = text1.length();
968
             int textLength2 = text2.length();
969
 
970
             int sourceLength = periodStr.length();
971
             for (int pos = position; pos < sourceLength; pos++) {
972
                 if (periodStr.regionMatches(true, pos, text1, 0, textLength1)) {
973
                     return pos;
974
                 }
975
                 if (periodStr.regionMatches(true, pos, text2, 0, textLength2)) {
976
                     return pos;
977
                 }
978
             }
979
             return ~position;
980
         }
981
     }
982
 
983
     //-----------------------------------------------------------------------
984
     
Builds a composite affix by merging two other affix implementations. 
986
 
987
     static class CompositeAffix implements PeriodFieldAffix {
988
         private final PeriodFieldAffix iLeft;
989
         private final PeriodFieldAffix iRight;
990
 
991
         CompositeAffix(PeriodFieldAffix left, PeriodFieldAffix right) {
992
              = left;
993
              = right;
994
         }
995
 
996
         public int calculatePrintedLength(int value) {
997
             return .calculatePrintedLength(value)
998
                 + .calculatePrintedLength(value);
999
         }
1001
        public void printTo(StringBuffer buf, int value) {
1002
            .printTo(buf, value);
1003
            .printTo(buf, value);
1004
        }
1006
        public void printTo(Writer out, int value) throws IOException {
1007
            .printTo(out, value);
1008
            .printTo(out, value);
1009
        }
1011
        public int parse(String periodStr, int position) {
1012
            position = .parse(periodStr, position);
1013
            if (position >= 0) {
1014
                position = .parse(periodStr, position);
1015
            }
1016
            return position;
1017
        }
1019
        public int scan(String periodStr, final int position) {
1020
            int pos = .scan(periodStr, position);
1021
            if (pos >= 0) {
1022
                return .scan(periodStr, pos);
1023
            }
1024
            return ~position;
1025
        }
1026
    }
1028
    //-----------------------------------------------------------------------
1029
    
Formats the numeric value of a field, potentially with prefix/suffix. 
1032
    static class FieldFormatter
1033
            implements PeriodPrinter, PeriodParser {
1034
        private final int iMinPrintedDigits;
1035
        private final int iPrintZeroSetting;
1036
        private final int iMaxParsedDigits;
1037
        private final boolean iRejectSignedValues;
        
        
The index of the field type, 0=year, etc.
1040
        private final int iFieldType;
        
The array of the latest formatter added for each type. This is shared between all the field formatters in a formatter. 
1045
        private final FieldFormatter[] iFieldFormatters;
1046
        
1047
        private final PeriodFieldAffix iPrefix;
1048
        private final PeriodFieldAffix iSuffix;
1050
        FieldFormatter(int minPrintedDigits, int printZeroSetting,
1051
                       int maxParsedDigits, boolean rejectSignedValues,
1052
                       int fieldType, FieldFormatter[] fieldFormatters,
1053
                       PeriodFieldAffix prefix, PeriodFieldAffix suffix) {
1054
             = minPrintedDigits;
1055
             = printZeroSetting;
1056
             = maxParsedDigits;
1057
             = rejectSignedValues;
1058
             = fieldType;
1059
             = fieldFormatters;
1060
             = prefix;
1061
             = suffix;
1062
        }
1064
        FieldFormatter(FieldFormatter field, PeriodFieldAffix suffix) {
1065
             = field.iMinPrintedDigits;
1066
             = field.iPrintZeroSetting;
1067
             = field.iMaxParsedDigits;
1068
             = field.iRejectSignedValues;
1069
             = field.iFieldType;
1070
             = field.iFieldFormatters;
1071
             = field.iPrefix;
1072
            if (field.iSuffix != null) {
1073
                suffix = new CompositeAffix(field.iSuffix, suffix);
1074
            }
1075
             = suffix;
1076
        }
1078
        public int countFieldsToPrint(ReadablePeriod period, int stopAt, Locale locale) {
1079
            if (stopAt <= 0) {
1080
                return 0;
1081
            }
1082
            if ( ==  || getFieldValue(period) != .) {
1083
                return 1;
1084
            }
1085
            return 0;
1086
        }
1088
        public int calculatePrintedLength(ReadablePeriod period, Locale locale) {
1089
            long valueLong = getFieldValue(period);
1090
            if (valueLong == .) {
1091
                return 0;
1092
            }
1094
            int sum = Math.max(FormatUtils.calculateDigitCount(valueLong), );
1095
            if ( >= ) {
1096
                // valueLong contains the seconds and millis fields
1097
                // the minimum output is 0.000, which is 4 digits
1098
                sum = Math.max(sum, 4);
1099
                // plus one for the decimal point
1100
                sum++;
1101
                if ( ==  &&
1102
                        (Math.abs(valueLong) % .) == 0) {
1103
                    sum -= 4; // remove three digits and decimal point
1104
                }
1105
                // reset valueLong to refer to the seconds part for the prefic/suffix calculation
1106
                valueLong = valueLong / .;
1107
            }
1108
            int value = (int) valueLong;
1110
            if ( != null) {
1111
                sum += .calculatePrintedLength(value);
1112
            }
1113
            if ( != null) {
1114
                sum += .calculatePrintedLength(value);
1115
            }
1117
            return sum;
1118
        }
1119
        
1120
        public void printTo(StringBuffer buf, ReadablePeriod period, Locale locale) {
1121
            long valueLong = getFieldValue(period);
1122
            if (valueLong == .) {
1123
                return;
1124
            }
1125
            int value = (int) valueLong;
1126
            if ( >= ) {
1127
                value = (int) (valueLong / .);
1128
            }
1130
            if ( != null) {
1131
                .printTo(buf, value);
1132
            }
1133
            int minDigits = ;
1134
            if (minDigits <= 1) {
1135
                FormatUtils.appendUnpaddedInteger(buf, value);
1136
            } else {
1137
                FormatUtils.appendPaddedInteger(buf, value, minDigits);
1138
            }
1139
            if ( >= ) {
1140
                int dp = (int) (Math.abs(valueLong) % .);
1141
                if ( ==  || dp > 0) {
1142
                    buf.append('.');
1143
                    FormatUtils.appendPaddedInteger(buf, dp, 3);
1144
                }
1145
            }
1146
            if ( != null) {
1147
                .printTo(buf, value);
1148
            }
1149
        }
1151
        public void printTo(Writer out, ReadablePeriod period, Locale locale) throws IOException {
1152
            long valueLong = getFieldValue(period);
1153
            if (valueLong == .) {
1154
                return;
1155
            }
1156
            int value = (int) valueLong;
1157
            if ( >= ) {
1158
                value = (int) (valueLong / .);
1159
            }
1161
            if ( != null) {
1162
                .printTo(out, value);
1163
            }
1164
            int minDigits = ;
1165
            if (minDigits <= 1) {
1166
                FormatUtils.writeUnpaddedInteger(out, value);
1167
            } else {
1168
                FormatUtils.writePaddedInteger(out, value, minDigits);
1169
            }
1170
            if ( >= ) {
1171
                int dp = (int) (Math.abs(valueLong) % .);
1172
                if ( ==  || dp > 0) {
1173
                    out.write('.');
1174
                    FormatUtils.writePaddedInteger(out, dp, 3);
1175
                }
1176
            }
1177
            if ( != null) {
1178
                .printTo(out, value);
1179
            }
1180
        }
1182
        public int parseInto(
1183
                ReadWritablePeriod period, String text, 
1184
                int position, Locale locale) {
1186
            boolean mustParse = ( == );
1188
            // Shortcut test.
1189
            if (position >= text.length()) {
1190
                return mustParse ? ~position : position;
1191
            }
1193
            if ( != null) {
1194
                position = .parse(text, position);
1195
                if (position >= 0) {
1196
                    // If prefix is found, then the parse must finish.
1197
                    mustParse = true;
1198
                } else {
1199
                    // Prefix not found, so bail.
1200
                    if (!mustParse) {
1201
                        // It's okay because parsing of this field is not
1202
                        // required. Don't return an error. Fields down the
1203
                        // chain can continue on, trying to parse.
1204
                        return ~position;
1205
                    }
1206
                    return position;
1207
                }
1208
            }
1210
            int suffixPos = -1;
1211
            if ( != null && !mustParse) {
1212
                // Pre-scan the suffix, to help determine if this field must be
1213
                // parsed.
1214
                suffixPos = .scan(text, position);
1215
                if (suffixPos >= 0) {
1216
                    // If suffix is found, then parse must finish.
1217
                    mustParse = true;
1218
                } else {
1219
                    // Suffix not found, so bail.
1220
                    if (!mustParse) {
1221
                        // It's okay because parsing of this field is not
1222
                        // required. Don't return an error. Fields down the
1223
                        // chain can continue on, trying to parse.
1224
                        return ~suffixPos;
1225
                    }
1226
                    return suffixPos;
1227
                }
1228
            }
1230
            if (!mustParse && !isSupported(period.getPeriodType(), )) {
1231
                // If parsing is not required and the field is not supported,
1232
                // exit gracefully so that another parser can continue on.
1233
                return position;
1234
            }
1236
            int limit;
1237
            if (suffixPos > 0) {
1238
                limit = Math.min(, suffixPos - position);
1239
            } else {
1240
                limit = Math.min(, text.length() - position);
1241
            }
1243
            // validate input number
1244
            int length = 0;
1245
            int fractPos = -1;
1246
            boolean hasDigits = false;
1247
            while (length < limit) {
1248
                char c = text.charAt(position + length);
1249
                // leading sign
1250
                if (length == 0 && (c == '-' || c == '+') && !) {
1251
                    boolean negative = c == '-';
1253
                    // Next character must be a digit.
1254
                    if (length + 1 >= limit || 
1255
                        (c = text.charAt(position + length + 1)) < '0' || c > '9')
1256
                    {
1257
                        break;
1258
                    }
1260
                    if (negative) {
1261
                        length++;
1262
                    } else {
1263
                        // Skip the '+' for parseInt to succeed.
1264
                        position++;
1265
                    }
1266
                    // Expand the limit to disregard the sign character.
1267
                    limit = Math.min(limit + 1, text.length() - position);
1268
                    continue;
1269
                }
1270
                // main number
1271
                if (c >= '0' && c <= '9') {
1272
                    hasDigits = true;
1273
                } else {
1274
                    if ((c == '.' || c == ',')
1275
                         && ( ==  ||  == )) {
1276
                        if (fractPos >= 0) {
1277
                            // can't have two decimals
1278
                            break;
1279
                        }
1280
                        fractPos = position + length + 1;
1281
                        // Expand the limit to disregard the decimal point.
1282
                        limit = Math.min(limit + 1, text.length() - position);
1283
                    } else {
1284
                        break;
1285
                    }
1286
                }
1287
                length++;
1288
            }
1290
            if (!hasDigits) {
1291
                return ~position;
1292
            }
1294
            if (suffixPos >= 0 && position + length != suffixPos) {
1295
                // If there are additional non-digit characters before the
1296
                // suffix is reached, then assume that the suffix found belongs
1297
                // to a field not yet reached. Return original position so that
1298
                // another parser can continue on.
1299
                return position;
1300
            }
1302
            if ( !=  &&  != ) {
1303
                // Handle common case.
1304
                setFieldValue(period, , parseInt(text, position, length));
1305
            } else if (fractPos < 0) {
1306
                setFieldValue(period, , parseInt(text, position, length));
1307
                setFieldValue(period, , 0);
1308
            } else {
1309
                int wholeValue = parseInt(text, position, fractPos - position - 1);
1310
                setFieldValue(period, , wholeValue);
1312
                int fractLen = position + length - fractPos;
1313
                int fractValue;
1314
                if (fractLen <= 0) {
1315
                    fractValue = 0;
1316
                } else {
1317
                    if (fractLen >= 3) {
1318
                        fractValue = parseInt(text, fractPos, 3);
1319
                    } else {
1320
                        fractValue = parseInt(text, fractPos, fractLen);
1321
                        if (fractLen == 1) {
1322
                            fractValue *= 100;
1323
                        } else {
1324
                            fractValue *= 10;
1325
                        }
1326
                    }
1327
                    if (wholeValue < 0) {
1328
                        fractValue = -fractValue;
1329
                    }
1330
                }
1332
                setFieldValue(period, , fractValue);
1333
            }
1334
                
1335
            position += length;
1337
            if (position >= 0 &&  != null) {
1338
                position = .parse(text, position);
1339
            }
1340
                
1341
            return position;
1342
        }

        

Parameters:
text text to parse
position position in text
length exact count of characters to parse
Returns:
parsed int value
1350
        private int parseInt(String text, int position, int length) {
1351
            if (length >= 10) {
1352
                // Since value may exceed max, use stock parser which checks for this.
1353
                return Integer.parseInt(text.substring(position, position + length));
1354
            }
1355
            if (length <= 0) {
1356
                return 0;
1357
            }
1358
            int value = text.charAt(position++);
1359
            length--;
1360
            boolean negative;
1361
            if (value == '-') {
1362
                if (--length < 0) {
1363
                    return 0;
1364
                }
1365
                negative = true;
1366
                value = text.charAt(position++);
1367
            } else {
1368
                negative = false;
1369
            }
1370
            value -= '0';
1371
            while (length-- > 0) {
1372
                value = ((value << 3) + (value << 1)) + text.charAt(position++) - '0';
1373
            }
1374
            return negative ? -value : value;
1375
        }

        

Returns:
Long.MAX_VALUE if nothing to print, otherwise value
1380
        long getFieldValue(ReadablePeriod period) {
1381
            PeriodType type;
1382
            if ( == ) {