查看本类的 API文档回源码主页即时通讯网 - 即时通讯开发者社区!
1   /*
2    * Copyright 2014 The Netty Project
3    *
4    * The Netty Project licenses this file to you under the Apache License,
5    * version 2.0 (the "License"); you may not use this file except in compliance
6    * with the License. You may obtain a copy of the License at:
7    *
8    *   https://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, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations
14   * under the License.
15   */
16  package io.netty.util;
17  
18  import io.netty.util.internal.EmptyArrays;
19  import io.netty.util.internal.InternalThreadLocalMap;
20  import io.netty.util.internal.ObjectUtil;
21  import io.netty.util.internal.PlatformDependent;
22  
23  import java.nio.ByteBuffer;
24  import java.nio.CharBuffer;
25  import java.nio.charset.Charset;
26  import java.nio.charset.CharsetEncoder;
27  import java.util.Arrays;
28  import java.util.Collection;
29  import java.util.List;
30  import java.util.regex.Pattern;
31  import java.util.regex.PatternSyntaxException;
32  
33  import static io.netty.util.internal.MathUtil.isOutOfBounds;
34  import static io.netty.util.internal.ObjectUtil.checkNotNull;
35  
36  /**
37   * A string which has been encoded into a character encoding whose character always takes a single byte, similarly to
38   * ASCII. It internally keeps its content in a byte array unlike {@link String}, which uses a character array, for
39   * reduced memory footprint and faster data transfer from/to byte-based data structures such as a byte array and
40   * {@link ByteBuffer}. It is often used in conjunction with {@code Headers} that require a {@link CharSequence}.
41   * <p>
42   * This class was designed to provide an immutable array of bytes, and caches some internal state based upon the value
43   * of this array. However underlying access to this byte array is provided via not copying the array on construction or
44   * {@link #array()}. If any changes are made to the underlying byte array it is the user's responsibility to call
45   * {@link #arrayChanged()} so the state of this class can be reset.
46   */
47  public final class AsciiString implements CharSequence, Comparable<CharSequence> {
48      public static final AsciiString EMPTY_STRING = cached("");
49      private static final char MAX_CHAR_VALUE = 255;
50  
51      public static final int INDEX_NOT_FOUND = -1;
52  
53      /**
54       * If this value is modified outside the constructor then call {@link #arrayChanged()}.
55       */
56      private final byte[] value;
57      /**
58       * Offset into {@link #value} that all operations should use when acting upon {@link #value}.
59       */
60      private final int offset;
61      /**
62       * Length in bytes for {@link #value} that we care about. This is independent from {@code value.length}
63       * because we may be looking at a subsection of the array.
64       */
65      private final int length;
66      /**
67       * The hash code is cached after it is first computed. It can be reset with {@link #arrayChanged()}.
68       */
69      private int hash;
70      /**
71       * Used to cache the {@link #toString()} value.
72       */
73      private String string;
74  
75      /**
76       * Initialize this byte string based upon a byte array. A copy will be made.
77       */
78      public AsciiString(byte[] value) {
79          this(value, true);
80      }
81  
82      /**
83       * Initialize this byte string based upon a byte array.
84       * {@code copy} determines if a copy is made or the array is shared.
85       */
86      public AsciiString(byte[] value, boolean copy) {
87          this(value, 0, value.length, copy);
88      }
89  
90      /**
91       * Construct a new instance from a {@code byte[]} array.
92       * @param copy {@code true} then a copy of the memory will be made. {@code false} the underlying memory
93       * will be shared.
94       */
95      public AsciiString(byte[] value, int start, int length, boolean copy) {
96          if (copy) {
97              final byte[] rangedCopy = new byte[length];
98              System.arraycopy(value, start, rangedCopy, 0, rangedCopy.length);
99              this.value = rangedCopy;
100             this.offset = 0;
101         } else {
102             if (isOutOfBounds(start, length, value.length)) {
103                 throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= start + length(" +
104                         length + ") <= " + "value.length(" + value.length + ')');
105             }
106             this.value = value;
107             this.offset = start;
108         }
109         this.length = length;
110     }
111 
112     /**
113      * Create a copy of the underlying storage from {@code value}.
114      * The copy will start at {@link ByteBuffer#position()} and copy {@link ByteBuffer#remaining()} bytes.
115      */
116     public AsciiString(ByteBuffer value) {
117         this(value, true);
118     }
119 
120     /**
121      * Initialize an instance based upon the underlying storage from {@code value}.
122      * There is a potential to share the underlying array storage if {@link ByteBuffer#hasArray()} is {@code true}.
123      * if {@code copy} is {@code true} a copy will be made of the memory.
124      * if {@code copy} is {@code false} the underlying storage will be shared, if possible.
125      */
126     public AsciiString(ByteBuffer value, boolean copy) {
127         this(value, value.position(), value.remaining(), copy);
128     }
129 
130     /**
131      * Initialize an {@link AsciiString} based upon the underlying storage from {@code value}.
132      * There is a potential to share the underlying array storage if {@link ByteBuffer#hasArray()} is {@code true}.
133      * if {@code copy} is {@code true} a copy will be made of the memory.
134      * if {@code copy} is {@code false} the underlying storage will be shared, if possible.
135      */
136     public AsciiString(ByteBuffer value, int start, int length, boolean copy) {
137         if (isOutOfBounds(start, length, value.capacity())) {
138             throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= start + length(" + length
139                             + ") <= " + "value.capacity(" + value.capacity() + ')');
140         }
141 
142         if (value.hasArray()) {
143             if (copy) {
144                 final int bufferOffset = value.arrayOffset() + start;
145                 this.value = Arrays.copyOfRange(value.array(), bufferOffset, bufferOffset + length);
146                 offset = 0;
147             } else {
148                 this.value = value.array();
149                 this.offset = start;
150             }
151         } else {
152             this.value = PlatformDependent.allocateUninitializedArray(length);
153             int oldPos = value.position();
154             value.get(this.value, 0, length);
155             value.position(oldPos);
156             this.offset = 0;
157         }
158         this.length = length;
159     }
160 
161     /**
162      * Create a copy of {@code value} into this instance assuming ASCII encoding.
163      */
164     public AsciiString(char[] value) {
165         this(value, 0, value.length);
166     }
167 
168     /**
169      * Create a copy of {@code value} into this instance assuming ASCII encoding.
170      * The copy will start at index {@code start} and copy {@code length} bytes.
171      */
172     public AsciiString(char[] value, int start, int length) {
173         if (isOutOfBounds(start, length, value.length)) {
174             throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= start + length(" + length
175                             + ") <= " + "value.length(" + value.length + ')');
176         }
177 
178         this.value = PlatformDependent.allocateUninitializedArray(length);
179         for (int i = 0, j = start; i < length; i++, j++) {
180             this.value[i] = c2b(value[j]);
181         }
182         this.offset = 0;
183         this.length = length;
184     }
185 
186     /**
187      * Create a copy of {@code value} into this instance using the encoding type of {@code charset}.
188      */
189     public AsciiString(char[] value, Charset charset) {
190         this(value, charset, 0, value.length);
191     }
192 
193     /**
194      * Create a copy of {@code value} into a this instance using the encoding type of {@code charset}.
195      * The copy will start at index {@code start} and copy {@code length} bytes.
196      */
197     public AsciiString(char[] value, Charset charset, int start, int length) {
198         CharBuffer cbuf = CharBuffer.wrap(value, start, length);
199         CharsetEncoder encoder = CharsetUtil.encoder(charset);
200         ByteBuffer nativeBuffer = ByteBuffer.allocate((int) (encoder.maxBytesPerChar() * length));
201         encoder.encode(cbuf, nativeBuffer, true);
202         final int bufferOffset = nativeBuffer.arrayOffset();
203         this.value = Arrays.copyOfRange(nativeBuffer.array(), bufferOffset, bufferOffset + nativeBuffer.position());
204         this.offset = 0;
205         this.length =  this.value.length;
206     }
207 
208     /**
209      * Create a copy of {@code value} into this instance assuming ASCII encoding.
210      */
211     public AsciiString(CharSequence value) {
212         this(value, 0, value.length());
213     }
214 
215     /**
216      * Create a copy of {@code value} into this instance assuming ASCII encoding.
217      * The copy will start at index {@code start} and copy {@code length} bytes.
218      */
219     public AsciiString(CharSequence value, int start, int length) {
220         if (isOutOfBounds(start, length, value.length())) {
221             throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= start + length(" + length
222                             + ") <= " + "value.length(" + value.length() + ')');
223         }
224 
225         this.value = PlatformDependent.allocateUninitializedArray(length);
226         for (int i = 0, j = start; i < length; i++, j++) {
227             this.value[i] = c2b(value.charAt(j));
228         }
229         this.offset = 0;
230         this.length = length;
231     }
232 
233     /**
234      * Create a copy of {@code value} into this instance using the encoding type of {@code charset}.
235      */
236     public AsciiString(CharSequence value, Charset charset) {
237         this(value, charset, 0, value.length());
238     }
239 
240     /**
241      * Create a copy of {@code value} into this instance using the encoding type of {@code charset}.
242      * The copy will start at index {@code start} and copy {@code length} bytes.
243      */
244     public AsciiString(CharSequence value, Charset charset, int start, int length) {
245         CharBuffer cbuf = CharBuffer.wrap(value, start, start + length);
246         CharsetEncoder encoder = CharsetUtil.encoder(charset);
247         ByteBuffer nativeBuffer = ByteBuffer.allocate((int) (encoder.maxBytesPerChar() * length));
248         encoder.encode(cbuf, nativeBuffer, true);
249         final int offset = nativeBuffer.arrayOffset();
250         this.value = Arrays.copyOfRange(nativeBuffer.array(), offset, offset + nativeBuffer.position());
251         this.offset = 0;
252         this.length = this.value.length;
253     }
254 
255     /**
256      * Iterates over the readable bytes of this buffer with the specified {@code processor} in ascending order.
257      *
258      * @return {@code -1} if the processor iterated to or beyond the end of the readable bytes.
259      *         The last-visited index If the {@link ByteProcessor#process(byte)} returned {@code false}.
260      */
261     public int forEachByte(ByteProcessor visitor) throws Exception {
262         return forEachByte0(0, length(), visitor);
263     }
264 
265     /**
266      * Iterates over the specified area of this buffer with the specified {@code processor} in ascending order.
267      * (i.e. {@code index}, {@code (index + 1)},  .. {@code (index + length - 1)}).
268      *
269      * @return {@code -1} if the processor iterated to or beyond the end of the specified area.
270      *         The last-visited index If the {@link ByteProcessor#process(byte)} returned {@code false}.
271      */
272     public int forEachByte(int index, int length, ByteProcessor visitor) throws Exception {
273         if (isOutOfBounds(index, length, length())) {
274             throw new IndexOutOfBoundsException("expected: " + "0 <= index(" + index + ") <= start + length(" + length
275                     + ") <= " + "length(" + length() + ')');
276         }
277         return forEachByte0(index, length, visitor);
278     }
279 
280     private int forEachByte0(int index, int length, ByteProcessor visitor) throws Exception {
281         final int len = offset + index + length;
282         for (int i = offset + index; i < len; ++i) {
283             if (!visitor.process(value[i])) {
284                 return i - offset;
285             }
286         }
287         return -1;
288     }
289 
290     /**
291      * Iterates over the readable bytes of this buffer with the specified {@code processor} in descending order.
292      *
293      * @return {@code -1} if the processor iterated to or beyond the beginning of the readable bytes.
294      *         The last-visited index If the {@link ByteProcessor#process(byte)} returned {@code false}.
295      */
296     public int forEachByteDesc(ByteProcessor visitor) throws Exception {
297         return forEachByteDesc0(0, length(), visitor);
298     }
299 
300     /**
301      * Iterates over the specified area of this buffer with the specified {@code processor} in descending order.
302      * (i.e. {@code (index + length - 1)}, {@code (index + length - 2)}, ... {@code index}).
303      *
304      * @return {@code -1} if the processor iterated to or beyond the beginning of the specified area.
305      *         The last-visited index If the {@link ByteProcessor#process(byte)} returned {@code false}.
306      */
307     public int forEachByteDesc(int index, int length, ByteProcessor visitor) throws Exception {
308         if (isOutOfBounds(index, length, length())) {
309             throw new IndexOutOfBoundsException("expected: " + "0 <= index(" + index + ") <= start + length(" + length
310                     + ") <= " + "length(" + length() + ')');
311         }
312         return forEachByteDesc0(index, length, visitor);
313     }
314 
315     private int forEachByteDesc0(int index, int length, ByteProcessor visitor) throws Exception {
316         final int end = offset + index;
317         for (int i = offset + index + length - 1; i >= end; --i) {
318             if (!visitor.process(value[i])) {
319                 return i - offset;
320             }
321         }
322         return -1;
323     }
324 
325     public byte byteAt(int index) {
326         // We must do a range check here to enforce the access does not go outside our sub region of the array.
327         // We rely on the array access itself to pick up the array out of bounds conditions
328         if (index < 0 || index >= length) {
329             throw new IndexOutOfBoundsException("index: " + index + " must be in the range [0," + length + ")");
330         }
331         // Try to use unsafe to avoid double checking the index bounds
332         if (PlatformDependent.hasUnsafe()) {
333             return PlatformDependent.getByte(value, index + offset);
334         }
335         return value[index + offset];
336     }
337 
338     /**
339      * Determine if this instance has 0 length.
340      */
341     public boolean isEmpty() {
342         return length == 0;
343     }
344 
345     /**
346      * The length in bytes of this instance.
347      */
348     @Override
349     public int length() {
350         return length;
351     }
352 
353     /**
354      * During normal use cases the {@link AsciiString} should be immutable, but if the underlying array is shared,
355      * and changes then this needs to be called.
356      */
357     public void arrayChanged() {
358         string = null;
359         hash = 0;
360     }
361 
362     /**
363      * This gives direct access to the underlying storage array.
364      * The {@link #toByteArray()} should be preferred over this method.
365      * If the return value is changed then {@link #arrayChanged()} must be called.
366      * @see #arrayOffset()
367      * @see #isEntireArrayUsed()
368      */
369     public byte[] array() {
370         return value;
371     }
372 
373     /**
374      * The offset into {@link #array()} for which data for this ByteString begins.
375      * @see #array()
376      * @see #isEntireArrayUsed()
377      */
378     public int arrayOffset() {
379         return offset;
380     }
381 
382     /**
383      * Determine if the storage represented by {@link #array()} is entirely used.
384      * @see #array()
385      */
386     public boolean isEntireArrayUsed() {
387         return offset == 0 && length == value.length;
388     }
389 
390     /**
391      * Converts this string to a byte array.
392      */
393     public byte[] toByteArray() {
394         return toByteArray(0, length());
395     }
396 
397     /**
398      * Converts a subset of this string to a byte array.
399      * The subset is defined by the range [{@code start}, {@code end}).
400      */
401     public byte[] toByteArray(int start, int end) {
402         return Arrays.copyOfRange(value, start + offset, end + offset);
403     }
404 
405     /**
406      * Copies the content of this string to a byte array.
407      *
408      * @param srcIdx the starting offset of characters to copy.
409      * @param dst the destination byte array.
410      * @param dstIdx the starting offset in the destination byte array.
411      * @param length the number of characters to copy.
412      */
413     public void copy(int srcIdx, byte[] dst, int dstIdx, int length) {
414         if (isOutOfBounds(srcIdx, length, length())) {
415             throw new IndexOutOfBoundsException("expected: " + "0 <= srcIdx(" + srcIdx + ") <= srcIdx + length("
416                             + length + ") <= srcLen(" + length() + ')');
417         }
418 
419         System.arraycopy(value, srcIdx + offset, checkNotNull(dst, "dst"), dstIdx, length);
420     }
421 
422     @Override
423     public char charAt(int index) {
424         return b2c(byteAt(index));
425     }
426 
427     /**
428      * Determines if this {@code String} contains the sequence of characters in the {@code CharSequence} passed.
429      *
430      * @param cs the character sequence to search for.
431      * @return {@code true} if the sequence of characters are contained in this string, otherwise {@code false}.
432      */
433     public boolean contains(CharSequence cs) {
434         return indexOf(cs) >= 0;
435     }
436 
437     /**
438      * Compares the specified string to this string using the ASCII values of the characters. Returns 0 if the strings
439      * contain the same characters in the same order. Returns a negative integer if the first non-equal character in
440      * this string has an ASCII value which is less than the ASCII value of the character at the same position in the
441      * specified string, or if this string is a prefix of the specified string. Returns a positive integer if the first
442      * non-equal character in this string has a ASCII value which is greater than the ASCII value of the character at
443      * the same position in the specified string, or if the specified string is a prefix of this string.
444      *
445      * @param string the string to compare.
446      * @return 0 if the strings are equal, a negative integer if this string is before the specified string, or a
447      *         positive integer if this string is after the specified string.
448      * @throws NullPointerException if {@code string} is {@code null}.
449      */
450     @Override
451     public int compareTo(CharSequence string) {
452         if (this == string) {
453             return 0;
454         }
455 
456         int result;
457         int length1 = length();
458         int length2 = string.length();
459         int minLength = Math.min(length1, length2);
460         for (int i = 0, j = arrayOffset(); i < minLength; i++, j++) {
461             result = b2c(value[j]) - string.charAt(i);
462             if (result != 0) {
463                 return result;
464             }
465         }
466 
467         return length1 - length2;
468     }
469 
470     /**
471      * Concatenates this string and the specified string.
472      *
473      * @param string the string to concatenate
474      * @return a new string which is the concatenation of this string and the specified string.
475      */
476     public AsciiString concat(CharSequence string) {
477         int thisLen = length();
478         int thatLen = string.length();
479         if (thatLen == 0) {
480             return this;
481         }
482 
483         if (string instanceof AsciiString) {
484             AsciiString that = (AsciiString) string;
485             if (isEmpty()) {
486                 return that;
487             }
488 
489             byte[] newValue = PlatformDependent.allocateUninitializedArray(thisLen + thatLen);
490             System.arraycopy(value, arrayOffset(), newValue, 0, thisLen);
491             System.arraycopy(that.value, that.arrayOffset(), newValue, thisLen, thatLen);
492             return new AsciiString(newValue, false);
493         }
494 
495         if (isEmpty()) {
496             return new AsciiString(string);
497         }
498 
499         byte[] newValue = PlatformDependent.allocateUninitializedArray(thisLen + thatLen);
500         System.arraycopy(value, arrayOffset(), newValue, 0, thisLen);
501         for (int i = thisLen, j = 0; i < newValue.length; i++, j++) {
502             newValue[i] = c2b(string.charAt(j));
503         }
504 
505         return new AsciiString(newValue, false);
506     }
507 
508     /**
509      * Compares the specified string to this string to determine if the specified string is a suffix.
510      *
511      * @param suffix the suffix to look for.
512      * @return {@code true} if the specified string is a suffix of this string, {@code false} otherwise.
513      * @throws NullPointerException if {@code suffix} is {@code null}.
514      */
515     public boolean endsWith(CharSequence suffix) {
516         int suffixLen = suffix.length();
517         return regionMatches(length() - suffixLen, suffix, 0, suffixLen);
518     }
519 
520     /**
521      * Compares the specified string to this string ignoring the case of the characters and returns true if they are
522      * equal.
523      *
524      * @param string the string to compare.
525      * @return {@code true} if the specified string is equal to this string, {@code false} otherwise.
526      */
527     public boolean contentEqualsIgnoreCase(CharSequence string) {
528         if (this == string) {
529             return true;
530         }
531 
532         if (string == null || string.length() != length()) {
533             return false;
534         }
535 
536         if (string instanceof AsciiString) {
537             AsciiString other = (AsciiString) string;
538             byte[] value = this.value;
539             if (offset == 0 && other.offset == 0 && length == value.length) {
540                 byte[] otherValue = other.value;
541                 for (int i = 0; i < value.length; ++i) {
542                     if (!equalsIgnoreCase(value[i], otherValue[i])) {
543                         return false;
544                     }
545                 }
546                 return true;
547             }
548             return misalignedEqualsIgnoreCase(other);
549         }
550 
551         byte[] value = this.value;
552         for (int i = offset, j = 0; j < string.length(); ++i, ++j) {
553             if (!equalsIgnoreCase(b2c(value[i]), string.charAt(j))) {
554                 return false;
555             }
556         }
557         return true;
558     }
559 
560     private boolean misalignedEqualsIgnoreCase(AsciiString other) {
561         byte[] value = this.value;
562         byte[] otherValue = other.value;
563         for (int i = offset, j = other.offset, end = offset + length; i < end; ++i, ++j) {
564             if (!equalsIgnoreCase(value[i], otherValue[j])) {
565                 return false;
566             }
567         }
568         return true;
569     }
570 
571     /**
572      * Copies the characters in this string to a character array.
573      *
574      * @return a character array containing the characters of this string.
575      */
576     public char[] toCharArray() {
577         return toCharArray(0, length());
578     }
579 
580     /**
581      * Copies the characters in this string to a character array.
582      *
583      * @return a character array containing the characters of this string.
584      */
585     public char[] toCharArray(int start, int end) {
586         int length = end - start;
587         if (length == 0) {
588             return EmptyArrays.EMPTY_CHARS;
589         }
590 
591         if (isOutOfBounds(start, length, length())) {
592             throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= srcIdx + length("
593                             + length + ") <= srcLen(" + length() + ')');
594         }
595 
596         final char[] buffer = new char[length];
597         for (int i = 0, j = start + arrayOffset(); i < length; i++, j++) {
598             buffer[i] = b2c(value[j]);
599         }
600         return buffer;
601     }
602 
603     /**
604      * Copied the content of this string to a character array.
605      *
606      * @param srcIdx the starting offset of characters to copy.
607      * @param dst the destination character array.
608      * @param dstIdx the starting offset in the destination byte array.
609      * @param length the number of characters to copy.
610      */
611     public void copy(int srcIdx, char[] dst, int dstIdx, int length) {
612         ObjectUtil.checkNotNull(dst, "dst");
613 
614         if (isOutOfBounds(srcIdx, length, length())) {
615             throw new IndexOutOfBoundsException("expected: " + "0 <= srcIdx(" + srcIdx + ") <= srcIdx + length("
616                             + length + ") <= srcLen(" + length() + ')');
617         }
618 
619         final int dstEnd = dstIdx + length;
620         for (int i = dstIdx, j = srcIdx + arrayOffset(); i < dstEnd; i++, j++) {
621             dst[i] = b2c(value[j]);
622         }
623     }
624 
625     /**
626      * Copies a range of characters into a new string.
627      * @param start the offset of the first character (inclusive).
628      * @return a new string containing the characters from start to the end of the string.
629      * @throws IndexOutOfBoundsException if {@code start < 0} or {@code start > length()}.
630      */
631     public AsciiString subSequence(int start) {
632         return subSequence(start, length());
633     }
634 
635     /**
636      * Copies a range of characters into a new string.
637      * @param start the offset of the first character (inclusive).
638      * @param end The index to stop at (exclusive).
639      * @return a new string containing the characters from start to the end of the string.
640      * @throws IndexOutOfBoundsException if {@code start < 0} or {@code start > length()}.
641      */
642     @Override
643     public AsciiString subSequence(int start, int end) {
644        return subSequence(start, end, true);
645     }
646 
647     /**
648      * Either copy or share a subset of underlying sub-sequence of bytes.
649      * @param start the offset of the first character (inclusive).
650      * @param end The index to stop at (exclusive).
651      * @param copy If {@code true} then a copy of the underlying storage will be made.
652      * If {@code false} then the underlying storage will be shared.
653      * @return a new string containing the characters from start to the end of the string.
654      * @throws IndexOutOfBoundsException if {@code start < 0} or {@code start > length()}.
655      */
656     public AsciiString subSequence(int start, int end, boolean copy) {
657         if (isOutOfBounds(start, end - start, length())) {
658             throw new IndexOutOfBoundsException("expected: 0 <= start(" + start + ") <= end (" + end + ") <= length("
659                             + length() + ')');
660         }
661 
662         if (start == 0 && end == length()) {
663             return this;
664         }
665 
666         if (end == start) {
667             return EMPTY_STRING;
668         }
669 
670         return new AsciiString(value, start + offset, end - start, copy);
671     }
672 
673     /**
674      * Searches in this string for the first index of the specified string. The search for the string starts at the
675      * beginning and moves towards the end of this string.
676      *
677      * @param string the string to find.
678      * @return the index of the first character of the specified string in this string, -1 if the specified string is
679      *         not a substring.
680      * @throws NullPointerException if {@code string} is {@code null}.
681      */
682     public int indexOf(CharSequence string) {
683         return indexOf(string, 0);
684     }
685 
686     /**
687      * Searches in this string for the index of the specified string. The search for the string starts at the specified
688      * offset and moves towards the end of this string.
689      *
690      * @param subString the string to find.
691      * @param start the starting offset.
692      * @return the index of the first character of the specified string in this string, -1 if the specified string is
693      *         not a substring.
694      * @throws NullPointerException if {@code subString} is {@code null}.
695      */
696     public int indexOf(CharSequence subString, int start) {
697         final int subCount = subString.length();
698         if (start < 0) {
699             start = 0;
700         }
701         if (subCount <= 0) {
702             return start < length ? start : length;
703         }
704         if (subCount > length - start) {
705             return INDEX_NOT_FOUND;
706         }
707 
708         final char firstChar = subString.charAt(0);
709         if (firstChar > MAX_CHAR_VALUE) {
710             return INDEX_NOT_FOUND;
711         }
712         final byte firstCharAsByte = c2b0(firstChar);
713         final int len = offset + length - subCount;
714         for (int i = start + offset; i <= len; ++i) {
715             if (value[i] == firstCharAsByte) {
716                 int o1 = i, o2 = 0;
717                 while (++o2 < subCount && b2c(value[++o1]) == subString.charAt(o2)) {
718                     // Intentionally empty
719                 }
720                 if (o2 == subCount) {
721                     return i - offset;
722                 }
723             }
724         }
725         return INDEX_NOT_FOUND;
726     }
727 
728     /**
729      * Searches in this string for the index of the specified char {@code ch}.
730      * The search for the char starts at the specified offset {@code start} and moves towards the end of this string.
731      *
732      * @param ch the char to find.
733      * @param start the starting offset.
734      * @return the index of the first occurrence of the specified char {@code ch} in this string,
735      * -1 if found no occurrence.
736      */
737     public int indexOf(char ch, int start) {
738         if (ch > MAX_CHAR_VALUE) {
739             return INDEX_NOT_FOUND;
740         }
741 
742         if (start < 0) {
743             start = 0;
744         }
745 
746         final byte chAsByte = c2b0(ch);
747         final int len = offset + length;
748         for (int i = start + offset; i < len; ++i) {
749             if (value[i] == chAsByte) {
750                 return i - offset;
751             }
752         }
753         return INDEX_NOT_FOUND;
754     }
755 
756     /**
757      * Searches in this string for the last index of the specified string. The search for the string starts at the end
758      * and moves towards the beginning of this string.
759      *
760      * @param string the string to find.
761      * @return the index of the first character of the specified string in this string, -1 if the specified string is
762      *         not a substring.
763      * @throws NullPointerException if {@code string} is {@code null}.
764      */
765     public int lastIndexOf(CharSequence string) {
766         // Use count instead of count - 1 so lastIndexOf("") answers count
767         return lastIndexOf(string, length);
768     }
769 
770     /**
771      * Searches in this string for the index of the specified string. The search for the string starts at the specified
772      * offset and moves towards the beginning of this string.
773      *
774      * @param subString the string to find.
775      * @param start the starting offset.
776      * @return the index of the first character of the specified string in this string , -1 if the specified string is
777      *         not a substring.
778      * @throws NullPointerException if {@code subString} is {@code null}.
779      */
780     public int lastIndexOf(CharSequence subString, int start) {
781         final int subCount = subString.length();
782         start = Math.min(start, length - subCount);
783         if (start < 0) {
784             return INDEX_NOT_FOUND;
785         }
786         if (subCount == 0) {
787             return start;
788         }
789 
790         final char firstChar = subString.charAt(0);
791         if (firstChar > MAX_CHAR_VALUE) {
792             return INDEX_NOT_FOUND;
793         }
794         final byte firstCharAsByte = c2b0(firstChar);
795         for (int i = offset + start; i >= offset; --i) {
796             if (value[i] == firstCharAsByte) {
797                 int o1 = i, o2 = 0;
798                 while (++o2 < subCount && b2c(value[++o1]) == subString.charAt(o2)) {
799                     // Intentionally empty
800                 }
801                 if (o2 == subCount) {
802                     return i - offset;
803                 }
804             }
805         }
806         return INDEX_NOT_FOUND;
807     }
808 
809     /**
810      * Compares the specified string to this string and compares the specified range of characters to determine if they
811      * are the same.
812      *
813      * @param thisStart the starting offset in this string.
814      * @param string the string to compare.
815      * @param start the starting offset in the specified string.
816      * @param length the number of characters to compare.
817      * @return {@code true} if the ranges of characters are equal, {@code false} otherwise
818      * @throws NullPointerException if {@code string} is {@code null}.
819      */
820     public boolean regionMatches(int thisStart, CharSequence string, int start, int length) {
821         ObjectUtil.checkNotNull(string, "string");
822 
823         if (start < 0 || string.length() - start < length) {
824             return false;
825         }
826 
827         final int thisLen = length();
828         if (thisStart < 0 || thisLen - thisStart < length) {
829             return false;
830         }
831 
832         if (length <= 0) {
833             return true;
834         }
835 
836         final int thatEnd = start + length;
837         for (int i = start, j = thisStart + arrayOffset(); i < thatEnd; i++, j++) {
838             if (b2c(value[j]) != string.charAt(i)) {
839                 return false;
840             }
841         }
842         return true;
843     }
844 
845     /**
846      * Compares the specified string to this string and compares the specified range of characters to determine if they
847      * are the same. When ignoreCase is true, the case of the characters is ignored during the comparison.
848      *
849      * @param ignoreCase specifies if case should be ignored.
850      * @param thisStart the starting offset in this string.
851      * @param string the string to compare.
852      * @param start the starting offset in the specified string.
853      * @param length the number of characters to compare.
854      * @return {@code true} if the ranges of characters are equal, {@code false} otherwise.
855      * @throws NullPointerException if {@code string} is {@code null}.
856      */
857     public boolean regionMatches(boolean ignoreCase, int thisStart, CharSequence string, int start, int length) {
858         if (!ignoreCase) {
859             return regionMatches(thisStart, string, start, length);
860         }
861 
862         ObjectUtil.checkNotNull(string, "string");
863 
864         final int thisLen = length();
865         if (thisStart < 0 || length > thisLen - thisStart) {
866             return false;
867         }
868         if (start < 0 || length > string.length() - start) {
869             return false;
870         }
871 
872         thisStart += arrayOffset();
873         final int thisEnd = thisStart + length;
874         while (thisStart < thisEnd) {
875             if (!equalsIgnoreCase(b2c(value[thisStart++]), string.charAt(start++))) {
876                 return false;
877             }
878         }
879         return true;
880     }
881 
882     /**
883      * Copies this string replacing occurrences of the specified character with another character.
884      *
885      * @param oldChar the character to replace.
886      * @param newChar the replacement character.
887      * @return a new string with occurrences of oldChar replaced by newChar.
888      */
889     public AsciiString replace(char oldChar, char newChar) {
890         if (oldChar > MAX_CHAR_VALUE) {
891             return this;
892         }
893 
894         final byte oldCharAsByte = c2b0(oldChar);
895         final byte newCharAsByte = c2b(newChar);
896         final int len = offset + length;
897         for (int i = offset; i < len; ++i) {
898             if (value[i] == oldCharAsByte) {
899                 byte[] buffer = PlatformDependent.allocateUninitializedArray(length());
900                 System.arraycopy(value, offset, buffer, 0, i - offset);
901                 buffer[i - offset] = newCharAsByte;
902                 ++i;
903                 for (; i < len; ++i) {
904                     byte oldValue = value[i];
905                     buffer[i - offset] = oldValue != oldCharAsByte ? oldValue : newCharAsByte;
906                 }
907                 return new AsciiString(buffer, false);
908             }
909         }
910         return this;
911     }
912 
913     /**
914      * Compares the specified string to this string to determine if the specified string is a prefix.
915      *
916      * @param prefix the string to look for.
917      * @return {@code true} if the specified string is a prefix of this string, {@code false} otherwise
918      * @throws NullPointerException if {@code prefix} is {@code null}.
919      */
920     public boolean startsWith(CharSequence prefix) {
921         return startsWith(prefix, 0);
922     }
923 
924     /**
925      * Compares the specified string to this string, starting at the specified offset, to determine if the specified
926      * string is a prefix.
927      *
928      * @param prefix the string to look for.
929      * @param start the starting offset.
930      * @return {@code true} if the specified string occurs in this string at the specified offset, {@code false}
931      *         otherwise.
932      * @throws NullPointerException if {@code prefix} is {@code null}.
933      */
934     public boolean startsWith(CharSequence prefix, int start) {
935         return regionMatches(start, prefix, 0, prefix.length());
936     }
937 
938     /**
939      * Converts the characters in this string to lowercase, using the default Locale.
940      *
941      * @return a new string containing the lowercase characters equivalent to the characters in this string.
942      */
943     public AsciiString toLowerCase() {
944         return AsciiStringUtil.toLowerCase(this);
945     }
946 
947     /**
948      * Converts the characters in this string to uppercase, using the default Locale.
949      *
950      * @return a new string containing the uppercase characters equivalent to the characters in this string.
951      */
952     public AsciiString toUpperCase() {
953         return AsciiStringUtil.toUpperCase(this);
954     }
955 
956     /**
957      * Copies this string removing white space characters from the beginning and end of the string, and tries not to
958      * copy if possible.
959      *
960      * @param c The {@link CharSequence} to trim.
961      * @return a new string with characters {@code <= \\u0020} removed from the beginning and the end.
962      */
963     public static CharSequence trim(CharSequence c) {
964         if (c instanceof AsciiString) {
965             return ((AsciiString) c).trim();
966         }
967         if (c instanceof String) {
968             return ((String) c).trim();
969         }
970         int start = 0, last = c.length() - 1;
971         int end = last;
972         while (start <= end && c.charAt(start) <= ' ') {
973             start++;
974         }
975         while (end >= start && c.charAt(end) <= ' ') {
976             end--;
977         }
978         if (start == 0 && end == last) {
979             return c;
980         }
981         return c.subSequence(start, end);
982     }
983 
984     /**
985      * Duplicates this string removing white space characters from the beginning and end of the
986      * string, without copying.
987      *
988      * @return a new string with characters {@code <= \\u0020} removed from the beginning and the end.
989      */
990     public AsciiString trim() {
991         int start = arrayOffset(), last = arrayOffset() + length() - 1;
992         int end = last;
993         while (start <= end && value[start] <= ' ') {
994             start++;
995         }
996         while (end >= start && value[end] <= ' ') {
997             end--;
998         }
999         if (start == 0 && end == last) {
1000             return this;
1001         }
1002         return new AsciiString(value, start, end - start + 1, false);
1003     }
1004 
1005     /**
1006      * Compares a {@code CharSequence} to this {@code String} to determine if their contents are equal.
1007      *
1008      * @param a the character sequence to compare to.
1009      * @return {@code true} if equal, otherwise {@code false}
1010      */
1011     public boolean contentEquals(CharSequence a) {
1012         if (this == a) {
1013             return true;
1014         }
1015 
1016         if (a == null || a.length() != length()) {
1017             return false;
1018         }
1019         if (a instanceof AsciiString) {
1020             return equals(a);
1021         }
1022 
1023         for (int i = arrayOffset(), j = 0; j < a.length(); ++i, ++j) {
1024             if (b2c(value[i]) != a.charAt(j)) {
1025                 return false;
1026             }
1027         }
1028         return true;
1029     }
1030 
1031     /**
1032      * Determines whether this string matches a given regular expression.
1033      *
1034      * @param expr the regular expression to be matched.
1035      * @return {@code true} if the expression matches, otherwise {@code false}.
1036      * @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid.
1037      * @throws NullPointerException if {@code expr} is {@code null}.
1038      */
1039     public boolean matches(String expr) {
1040         return Pattern.matches(expr, this);
1041     }
1042 
1043     /**
1044      * Splits this string using the supplied regular expression {@code expr}. The parameter {@code max} controls the
1045      * behavior how many times the pattern is applied to the string.
1046      *
1047      * @param expr the regular expression used to divide the string.
1048      * @param max the number of entries in the resulting array.
1049      * @return an array of Strings created by separating the string along matches of the regular expression.
1050      * @throws NullPointerException if {@code expr} is {@code null}.
1051      * @throws PatternSyntaxException if the syntax of the supplied regular expression is not valid.
1052      * @see Pattern#split(CharSequence, int)
1053      */
1054     public AsciiString[] split(String expr, int max) {
1055         return toAsciiStringArray(Pattern.compile(expr).split(this, max));
1056     }
1057 
1058     /**
1059      * Splits the specified {@link String} with the specified delimiter..
1060      */
1061     public AsciiString[] split(char delim) {
1062         final List<AsciiString> res = InternalThreadLocalMap.get().arrayList();
1063 
1064         int start = 0;
1065         final int length = length();
1066         for (int i = start; i < length; i++) {
1067             if (charAt(i) == delim) {
1068                 if (start == i) {
1069                     res.add(EMPTY_STRING);
1070                 } else {
1071                     res.add(new AsciiString(value, start + arrayOffset(), i - start, false));
1072                 }
1073                 start = i + 1;
1074             }
1075         }
1076 
1077         if (start == 0) { // If no delimiter was found in the value
1078             res.add(this);
1079         } else {
1080             if (start != length) {
1081                 // Add the last element if it's not empty.
1082                 res.add(new AsciiString(value, start + arrayOffset(), length - start, false));
1083             } else {
1084                 // Truncate trailing empty elements.
1085                 for (int i = res.size() - 1; i >= 0; i--) {
1086                     if (res.get(i).isEmpty()) {
1087                         res.remove(i);
1088                     } else {
1089                         break;
1090                     }
1091                 }
1092             }
1093         }
1094 
1095         return res.toArray(EmptyArrays.EMPTY_ASCII_STRINGS);
1096     }
1097 
1098     /**
1099      * {@inheritDoc}
1100      * <p>
1101      * Provides a case-insensitive hash code for Ascii like byte strings.
1102      */
1103     @Override
1104     public int hashCode() {
1105         int h = hash;
1106         if (h == 0) {
1107             h = PlatformDependent.hashCodeAscii(value, offset, length);
1108             hash = h;
1109         }
1110         return h;
1111     }
1112 
1113     @Override
1114     public boolean equals(Object obj) {
1115         if (obj == null || obj.getClass() != AsciiString.class) {
1116             return false;
1117         }
1118         if (this == obj) {
1119             return true;
1120         }
1121 
1122         AsciiString other = (AsciiString) obj;
1123         return length() == other.length() &&
1124                hashCode() == other.hashCode() &&
1125                PlatformDependent.equals(array(), arrayOffset(), other.array(), other.arrayOffset(), length());
1126     }
1127 
1128     /**
1129      * Translates the entire byte string to a {@link String}.
1130      * @see #toString(int)
1131      */
1132     @Override
1133     public String toString() {
1134         String cache = string;
1135         if (cache == null) {
1136             cache = toString(0);
1137             string = cache;
1138         }
1139         return cache;
1140     }
1141 
1142     /**
1143      * Translates the entire byte string to a {@link String} using the {@code charset} encoding.
1144      * @see #toString(int, int)
1145      */
1146     public String toString(int start) {
1147         return toString(start, length());
1148     }
1149 
1150     /**
1151      * Translates the [{@code start}, {@code end}) range of this byte string to a {@link String}.
1152      */
1153     public String toString(int start, int end) {
1154         int length = end - start;
1155         if (length == 0) {
1156             return "";
1157         }
1158 
1159         if (isOutOfBounds(start, length, length())) {
1160             throw new IndexOutOfBoundsException("expected: " + "0 <= start(" + start + ") <= srcIdx + length("
1161                             + length + ") <= srcLen(" + length() + ')');
1162         }
1163 
1164         @SuppressWarnings("deprecation")
1165         final String str = new String(value, 0, start + offset, length);
1166         return str;
1167     }
1168 
1169     public boolean parseBoolean() {
1170         return length >= 1 && value[offset] != 0;
1171     }
1172 
1173     public char parseChar() {
1174         return parseChar(0);
1175     }
1176 
1177     public char parseChar(int start) {
1178         if (start + 1 >= length()) {
1179             throw new IndexOutOfBoundsException("2 bytes required to convert to character. index " +
1180                     start + " would go out of bounds.");
1181         }
1182         final int startWithOffset = start + offset;
1183         return (char) ((b2c(value[startWithOffset]) << 8) | b2c(value[startWithOffset + 1]));
1184     }
1185 
1186     public short parseShort() {
1187         return parseShort(0, length(), 10);
1188     }
1189 
1190     public short parseShort(int radix) {
1191         return parseShort(0, length(), radix);
1192     }
1193 
1194     public short parseShort(int start, int end) {
1195         return parseShort(start, end, 10);
1196     }
1197 
1198     public short parseShort(int start, int end, int radix) {
1199         int intValue = parseInt(start, end, radix);
1200         short result = (short) intValue;
1201         if (result != intValue) {
1202             throw new NumberFormatException(subSequence(start, end, false).toString());
1203         }
1204         return result;
1205     }
1206 
1207     public int parseInt() {
1208         return parseInt(0, length(), 10);
1209     }
1210 
1211     public int parseInt(int radix) {
1212         return parseInt(0, length(), radix);
1213     }
1214 
1215     public int parseInt(int start, int end) {
1216         return parseInt(start, end, 10);
1217     }
1218 
1219     public int parseInt(int start, int end, int radix) {
1220         if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
1221             throw new NumberFormatException();
1222         }
1223 
1224         if (start == end) {
1225             throw new NumberFormatException();
1226         }
1227 
1228         int i = start;
1229         boolean negative = byteAt(i) == '-';
1230         if (negative && ++i == end) {
1231             throw new NumberFormatException(subSequence(start, end, false).toString());
1232         }
1233 
1234         return parseInt(i, end, radix, negative);
1235     }
1236 
1237     private int parseInt(int start, int end, int radix, boolean negative) {
1238         int max = Integer.MIN_VALUE / radix;
1239         int result = 0;
1240         int currOffset = start;
1241         while (currOffset < end) {
1242             int digit = Character.digit((char) (value[currOffset++ + offset] & 0xFF), radix);
1243             if (digit == -1) {
1244                 throw new NumberFormatException(subSequence(start, end, false).toString());
1245             }
1246             if (max > result) {
1247                 throw new NumberFormatException(subSequence(start, end, false).toString());
1248             }
1249             int next = result * radix - digit;
1250             if (next > result) {
1251                 throw new NumberFormatException(subSequence(start, end, false).toString());
1252             }
1253             result = next;
1254         }
1255         if (!negative) {
1256             result = -result;
1257             if (result < 0) {
1258                 throw new NumberFormatException(subSequence(start, end, false).toString());
1259             }
1260         }
1261         return result;
1262     }
1263 
1264     public long parseLong() {
1265         return parseLong(0, length(), 10);
1266     }
1267 
1268     public long parseLong(int radix) {
1269         return parseLong(0, length(), radix);
1270     }
1271 
1272     public long parseLong(int start, int end) {
1273         return parseLong(start, end, 10);
1274     }
1275 
1276     public long parseLong(int start, int end, int radix) {
1277         if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
1278             throw new NumberFormatException();
1279         }
1280 
1281         if (start == end) {
1282             throw new NumberFormatException();
1283         }
1284 
1285         int i = start;
1286         boolean negative = byteAt(i) == '-';
1287         if (negative && ++i == end) {
1288             throw new NumberFormatException(subSequence(start, end, false).toString());
1289         }
1290 
1291         return parseLong(i, end, radix, negative);
1292     }
1293 
1294     private long parseLong(int start, int end, int radix, boolean negative) {
1295         long max = Long.MIN_VALUE / radix;
1296         long result = 0;
1297         int currOffset = start;
1298         while (currOffset < end) {
1299             int digit = Character.digit((char) (value[currOffset++ + offset] & 0xFF), radix);
1300             if (digit == -1) {
1301                 throw new NumberFormatException(subSequence(start, end, false).toString());
1302             }
1303             if (max > result) {
1304                 throw new NumberFormatException(subSequence(start, end, false).toString());
1305             }
1306             long next = result * radix - digit;
1307             if (next > result) {
1308                 throw new NumberFormatException(subSequence(start, end, false).toString());
1309             }
1310             result = next;
1311         }
1312         if (!negative) {
1313             result = -result;
1314             if (result < 0) {
1315                 throw new NumberFormatException(subSequence(start, end, false).toString());
1316             }
1317         }
1318         return result;
1319     }
1320 
1321     public float parseFloat() {
1322         return parseFloat(0, length());
1323     }
1324 
1325     public float parseFloat(int start, int end) {
1326         return Float.parseFloat(toString(start, end));
1327     }
1328 
1329     public double parseDouble() {
1330         return parseDouble(0, length());
1331     }
1332 
1333     public double parseDouble(int start, int end) {
1334         return Double.parseDouble(toString(start, end));
1335     }
1336 
1337     public static final HashingStrategy<CharSequence> CASE_INSENSITIVE_HASHER =
1338             new HashingStrategy<CharSequence>() {
1339         @Override
1340         public int hashCode(CharSequence o) {
1341             return AsciiString.hashCode(o);
1342         }
1343 
1344         @Override
1345         public boolean equals(CharSequence a, CharSequence b) {
1346             return AsciiString.contentEqualsIgnoreCase(a, b);
1347         }
1348     };
1349 
1350     public static final HashingStrategy<CharSequence> CASE_SENSITIVE_HASHER =
1351             new HashingStrategy<CharSequence>() {
1352         @Override
1353         public int hashCode(CharSequence o) {
1354             return AsciiString.hashCode(o);
1355         }
1356 
1357         @Override
1358         public boolean equals(CharSequence a, CharSequence b) {
1359             return AsciiString.contentEquals(a, b);
1360         }
1361     };
1362 
1363     /**
1364      * Returns an {@link AsciiString} containing the given character sequence. If the given string is already a
1365      * {@link AsciiString}, just returns the same instance.
1366      */
1367     public static AsciiString of(CharSequence string) {
1368         return string instanceof AsciiString ? (AsciiString) string : new AsciiString(string);
1369     }
1370 
1371     /**
1372      * Returns an {@link AsciiString} containing the given string and retains/caches the input
1373      * string for later use in {@link #toString()}.
1374      * Used for the constants (which already stored in the JVM's string table) and in cases
1375      * where the guaranteed use of the {@link #toString()} method.
1376      */
1377     public static AsciiString cached(String string) {
1378         AsciiString asciiString = new AsciiString(string);
1379         asciiString.string = string;
1380         return asciiString;
1381     }
1382 
1383     /**
1384      * Returns the case-insensitive hash code of the specified string. Note that this method uses the same hashing
1385      * algorithm with {@link #hashCode()} so that you can put both {@link AsciiString}s and arbitrary
1386      * {@link CharSequence}s into the same headers.
1387      */
1388     public static int hashCode(CharSequence value) {
1389         if (value == null) {
1390             return 0;
1391         }
1392         if (value instanceof AsciiString) {
1393             return value.hashCode();
1394         }
1395 
1396         return PlatformDependent.hashCodeAscii(value);
1397     }
1398 
1399     /**
1400      * Determine if {@code a} contains {@code b} in a case sensitive manner.
1401      */
1402     public static boolean contains(CharSequence a, CharSequence b) {
1403         return contains(a, b, DefaultCharEqualityComparator.INSTANCE);
1404     }
1405 
1406     /**
1407      * Determine if {@code a} contains {@code b} in a case insensitive manner.
1408      */
1409     public static boolean containsIgnoreCase(CharSequence a, CharSequence b) {
1410         return contains(a, b, AsciiCaseInsensitiveCharEqualityComparator.INSTANCE);
1411     }
1412 
1413     /**
1414      * Returns {@code true} if both {@link CharSequence}'s are equals when ignore the case. This only supports 8-bit
1415      * ASCII.
1416      */
1417     public static boolean contentEqualsIgnoreCase(CharSequence a, CharSequence b) {
1418         if (a == null || b == null) {
1419             return a == b;
1420         }
1421 
1422         if (a instanceof AsciiString) {
1423             return ((AsciiString) a).contentEqualsIgnoreCase(b);
1424         }
1425         if (b instanceof AsciiString) {
1426             return ((AsciiString) b).contentEqualsIgnoreCase(a);
1427         }
1428 
1429         if (a.length() != b.length()) {
1430             return false;
1431         }
1432         for (int i = 0; i < a.length(); ++i) {
1433             if (!equalsIgnoreCase(a.charAt(i),  b.charAt(i))) {
1434                 return false;
1435             }
1436         }
1437         return true;
1438     }
1439 
1440     /**
1441      * Determine if {@code collection} contains {@code value} and using
1442      * {@link #contentEqualsIgnoreCase(CharSequence, CharSequence)} to compare values.
1443      * @param collection The collection to look for and equivalent element as {@code value}.
1444      * @param value The value to look for in {@code collection}.
1445      * @return {@code true} if {@code collection} contains {@code value} according to
1446      * {@link #contentEqualsIgnoreCase(CharSequence, CharSequence)}. {@code false} otherwise.
1447      * @see #contentEqualsIgnoreCase(CharSequence, CharSequence)
1448      */
1449     public static boolean containsContentEqualsIgnoreCase(Collection<CharSequence> collection, CharSequence value) {
1450         for (CharSequence v : collection) {
1451             if (contentEqualsIgnoreCase(value, v)) {
1452                 return true;
1453             }
1454         }
1455         return false;
1456     }
1457 
1458     /**
1459      * Determine if {@code a} contains all of the values in {@code b} using
1460      * {@link #contentEqualsIgnoreCase(CharSequence, CharSequence)} to compare values.
1461      * @param a The collection under test.
1462      * @param b The values to test for.
1463      * @return {@code true} if {@code a} contains all of the values in {@code b} using
1464      * {@link #contentEqualsIgnoreCase(CharSequence, CharSequence)} to compare values. {@code false} otherwise.
1465      * @see #contentEqualsIgnoreCase(CharSequence, CharSequence)
1466      */
1467     public static boolean containsAllContentEqualsIgnoreCase(Collection<CharSequence> a, Collection<CharSequence> b) {
1468         for (CharSequence v : b) {
1469             if (!containsContentEqualsIgnoreCase(a, v)) {
1470                 return false;
1471             }
1472         }
1473         return true;
1474     }
1475 
1476     /**
1477      * Returns {@code true} if the content of both {@link CharSequence}'s are equals. This only supports 8-bit ASCII.
1478      */
1479     public static boolean contentEquals(CharSequence a, CharSequence b) {
1480         if (a == null || b == null) {
1481             return a == b;
1482         }
1483 
1484         if (a instanceof AsciiString) {
1485             return ((AsciiString) a).contentEquals(b);
1486         }
1487 
1488         if (b instanceof AsciiString) {
1489             return ((AsciiString) b).contentEquals(a);
1490         }
1491 
1492         if (a.length() != b.length()) {
1493             return false;
1494         }
1495         for (int i = 0; i <  a.length(); ++i) {
1496             if (a.charAt(i) != b.charAt(i)) {
1497                 return false;
1498             }
1499         }
1500         return true;
1501     }
1502 
1503     private static AsciiString[] toAsciiStringArray(String[] jdkResult) {
1504         AsciiString[] res = new AsciiString[jdkResult.length];
1505         for (int i = 0; i < jdkResult.length; i++) {
1506             res[i] = new AsciiString(jdkResult[i]);
1507         }
1508         return res;
1509     }
1510 
1511     private interface CharEqualityComparator {
1512         boolean equals(char a, char b);
1513     }
1514 
1515     private static final class DefaultCharEqualityComparator implements CharEqualityComparator {
1516         static final DefaultCharEqualityComparator INSTANCE = new DefaultCharEqualityComparator();
1517         private DefaultCharEqualityComparator() { }
1518 
1519         @Override
1520         public boolean equals(char a, char b) {
1521             return a == b;
1522         }
1523     }
1524 
1525     private static final class AsciiCaseInsensitiveCharEqualityComparator implements CharEqualityComparator {
1526         static final AsciiCaseInsensitiveCharEqualityComparator
1527                 INSTANCE = new AsciiCaseInsensitiveCharEqualityComparator();
1528         private AsciiCaseInsensitiveCharEqualityComparator() { }
1529 
1530         @Override
1531         public boolean equals(char a, char b) {
1532             return equalsIgnoreCase(a, b);
1533         }
1534     }
1535 
1536     private static final class GeneralCaseInsensitiveCharEqualityComparator implements CharEqualityComparator {
1537         static final GeneralCaseInsensitiveCharEqualityComparator
1538                 INSTANCE = new GeneralCaseInsensitiveCharEqualityComparator();
1539         private GeneralCaseInsensitiveCharEqualityComparator() { }
1540 
1541         @Override
1542         public boolean equals(char a, char b) {
1543             //For motivation, why we need two checks, see comment in String#regionMatches
1544             return Character.toUpperCase(a) == Character.toUpperCase(b) ||
1545                 Character.toLowerCase(a) == Character.toLowerCase(b);
1546         }
1547     }
1548 
1549     private static boolean contains(CharSequence a, CharSequence b, CharEqualityComparator cmp) {
1550         if (a == null || b == null || a.length() < b.length()) {
1551             return false;
1552         }
1553         if (b.length() == 0) {
1554             return true;
1555         }
1556         int bStart = 0;
1557         for (int i = 0; i < a.length(); ++i) {
1558             if (cmp.equals(b.charAt(bStart), a.charAt(i))) {
1559                 // If b is consumed then true.
1560                 if (++bStart == b.length()) {
1561                     return true;
1562                 }
1563             } else if (a.length() - i < b.length()) {
1564                 // If there are not enough characters left in a for b to be contained, then false.
1565                 return false;
1566             } else {
1567                 bStart = 0;
1568             }
1569         }
1570         return false;
1571     }
1572 
1573     private static boolean regionMatchesCharSequences(final CharSequence cs, final int csStart,
1574                                          final CharSequence string, final int start, final int length,
1575                                          CharEqualityComparator charEqualityComparator) {
1576         //general purpose implementation for CharSequences
1577         if (csStart < 0 || length > cs.length() - csStart) {
1578             return false;
1579         }
1580         if (start < 0 || length > string.length() - start) {
1581             return false;
1582         }
1583 
1584         int csIndex = csStart;
1585         int csEnd = csIndex + length;
1586         int stringIndex = start;
1587 
1588         while (csIndex < csEnd) {
1589             char c1 = cs.charAt(csIndex++);
1590             char c2 = string.charAt(stringIndex++);
1591 
1592             if (!charEqualityComparator.equals(c1, c2)) {
1593                 return false;
1594             }
1595         }
1596         return true;
1597     }
1598 
1599     /**
1600      * This methods make regionMatches operation correctly for any chars in strings
1601      * @param cs the {@code CharSequence} to be processed
1602      * @param ignoreCase specifies if case should be ignored.
1603      * @param csStart the starting offset in the {@code cs} CharSequence
1604      * @param string the {@code CharSequence} to compare.
1605      * @param start the starting offset in the specified {@code string}.
1606      * @param length the number of characters to compare.
1607      * @return {@code true} if the ranges of characters are equal, {@code false} otherwise.
1608      */
1609     public static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, final int csStart,
1610                                         final CharSequence string, final int start, final int length) {
1611         if (cs == null || string == null) {
1612             return false;
1613         }
1614 
1615         if (cs instanceof String && string instanceof String) {
1616             return ((String) cs).regionMatches(ignoreCase, csStart, (String) string, start, length);
1617         }
1618 
1619         if (cs instanceof AsciiString) {
1620             return ((AsciiString) cs).regionMatches(ignoreCase, csStart, string, start, length);
1621         }
1622 
1623         return regionMatchesCharSequences(cs, csStart, string, start, length,
1624                                             ignoreCase ? GeneralCaseInsensitiveCharEqualityComparator.INSTANCE :
1625                                                     DefaultCharEqualityComparator.INSTANCE);
1626     }
1627 
1628     /**
1629      * This is optimized version of regionMatches for string with ASCII chars only
1630      * @param cs the {@code CharSequence} to be processed
1631      * @param ignoreCase specifies if case should be ignored.
1632      * @param csStart the starting offset in the {@code cs} CharSequence
1633      * @param string the {@code CharSequence} to compare.
1634      * @param start the starting offset in the specified {@code string}.
1635      * @param length the number of characters to compare.
1636      * @return {@code true} if the ranges of characters are equal, {@code false} otherwise.
1637      */
1638     public static boolean regionMatchesAscii(final CharSequence cs, final boolean ignoreCase, final int csStart,
1639                                         final CharSequence string, final int start, final int length) {
1640         if (cs == null || string == null) {
1641             return false;
1642         }
1643 
1644         if (!ignoreCase && cs instanceof String && string instanceof String) {
1645             //we don't call regionMatches from String for ignoreCase==true. It's a general purpose method,
1646             //which make complex comparison in case of ignoreCase==true, which is useless for ASCII-only strings.
1647             //To avoid applying this complex ignore-case comparison, we will use regionMatchesCharSequences
1648             return ((String) cs).regionMatches(false, csStart, (String) string, start, length);
1649         }
1650 
1651         if (cs instanceof AsciiString) {
1652             return ((AsciiString) cs).regionMatches(ignoreCase, csStart, string, start, length);
1653         }
1654 
1655         return regionMatchesCharSequences(cs, csStart, string, start, length,
1656                                           ignoreCase ? AsciiCaseInsensitiveCharEqualityComparator.INSTANCE :
1657                                                       DefaultCharEqualityComparator.INSTANCE);
1658     }
1659 
1660     /**
1661      * <p>Case in-sensitive find of the first index within a CharSequence
1662      * from the specified position.</p>
1663      *
1664      * <p>A {@code null} CharSequence will return {@code -1}.
1665      * A negative start position is treated as zero.
1666      * An empty ("") search CharSequence always matches.
1667      * A start position greater than the string length only matches
1668      * an empty search CharSequence.</p>
1669      *
1670      * <pre>
1671      * AsciiString.indexOfIgnoreCase(null, *, *)          = -1
1672      * AsciiString.indexOfIgnoreCase(*, null, *)          = -1
1673      * AsciiString.indexOfIgnoreCase("", "", 0)           = 0
1674      * AsciiString.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
1675      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
1676      * AsciiString.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
1677      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
1678      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
1679      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
1680      * AsciiString.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
1681      * AsciiString.indexOfIgnoreCase("abc", "", 9)        = -1
1682      * </pre>
1683      *
1684      * @param str  the CharSequence to check, may be null
1685      * @param searchStr  the CharSequence to find, may be null
1686      * @param startPos  the start position, negative treated as zero
1687      * @return the first index of the search CharSequence (always &ge; startPos),
1688      *  -1 if no match or {@code null} string input
1689      */
1690     public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int startPos) {
1691         if (str == null || searchStr == null) {
1692             return INDEX_NOT_FOUND;
1693         }
1694         if (startPos < 0) {
1695             startPos = 0;
1696         }
1697         int searchStrLen = searchStr.length();
1698         final int endLimit = str.length() - searchStrLen + 1;
1699         if (startPos > endLimit) {
1700             return INDEX_NOT_FOUND;
1701         }
1702         if (searchStrLen == 0) {
1703             return startPos;
1704         }
1705         for (int i = startPos; i < endLimit; i++) {
1706             if (regionMatches(str, true, i, searchStr, 0, searchStrLen)) {
1707                 return i;
1708             }
1709         }
1710         return INDEX_NOT_FOUND;
1711     }
1712 
1713     /**
1714      * <p>Case in-sensitive find of the first index within a CharSequence
1715      * from the specified position. This method optimized and works correctly for ASCII CharSequences only</p>
1716      *
1717      * <p>A {@code null} CharSequence will return {@code -1}.
1718      * A negative start position is treated as zero.
1719      * An empty ("") search CharSequence always matches.
1720      * A start position greater than the string length only matches
1721      * an empty search CharSequence.</p>
1722      *
1723      * <pre>
1724      * AsciiString.indexOfIgnoreCase(null, *, *)          = -1
1725      * AsciiString.indexOfIgnoreCase(*, null, *)          = -1
1726      * AsciiString.indexOfIgnoreCase("", "", 0)           = 0
1727      * AsciiString.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0
1728      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2
1729      * AsciiString.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
1730      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5
1731      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1
1732      * AsciiString.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
1733      * AsciiString.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
1734      * AsciiString.indexOfIgnoreCase("abc", "", 9)        = -1
1735      * </pre>
1736      *
1737      * @param str  the CharSequence to check, may be null
1738      * @param searchStr  the CharSequence to find, may be null
1739      * @param startPos  the start position, negative treated as zero
1740      * @return the first index of the search CharSequence (always &ge; startPos),
1741      *  -1 if no match or {@code null} string input
1742      */
1743     public static int indexOfIgnoreCaseAscii(final CharSequence str, final CharSequence searchStr, int startPos) {
1744         if (str == null || searchStr == null) {
1745             return INDEX_NOT_FOUND;
1746         }
1747         if (startPos < 0) {
1748             startPos = 0;
1749         }
1750         int searchStrLen = searchStr.length();
1751         final int endLimit = str.length() - searchStrLen + 1;
1752         if (startPos > endLimit) {
1753             return INDEX_NOT_FOUND;
1754         }
1755         if (searchStrLen == 0) {
1756             return startPos;
1757         }
1758         for (int i = startPos; i < endLimit; i++) {
1759             if (regionMatchesAscii(str, true, i, searchStr, 0, searchStrLen)) {
1760                 return i;
1761             }
1762         }
1763         return INDEX_NOT_FOUND;
1764     }
1765 
1766     /**
1767      * <p>Finds the first index in the {@code CharSequence} that matches the
1768      * specified character.</p>
1769      *
1770      * @param cs  the {@code CharSequence} to be processed, not null
1771      * @param searchChar the char to be searched for
1772      * @param start  the start index, negative starts at the string start
1773      * @return the index where the search char was found,
1774      * -1 if char {@code searchChar} is not found or {@code cs == null}
1775      */
1776     //-----------------------------------------------------------------------
1777     public static int indexOf(final CharSequence cs, final char searchChar, int start) {
1778         if (cs instanceof String) {
1779             return ((String) cs).indexOf(searchChar, start);
1780         } else if (cs instanceof AsciiString) {
1781             return ((AsciiString) cs).indexOf(searchChar, start);
1782         }
1783         if (cs == null) {
1784             return INDEX_NOT_FOUND;
1785         }
1786         final int sz = cs.length();
1787         for (int i = start < 0 ? 0 : start; i < sz; i++) {
1788             if (cs.charAt(i) == searchChar) {
1789                 return i;
1790             }
1791         }
1792         return INDEX_NOT_FOUND;
1793     }
1794 
1795     private static boolean equalsIgnoreCase(byte a, byte b) {
1796         return a == b || AsciiStringUtil.toLowerCase(a) == AsciiStringUtil.toLowerCase(b);
1797     }
1798 
1799     private static boolean equalsIgnoreCase(char a, char b) {
1800         return a == b || toLowerCase(a) == toLowerCase(b);
1801     }
1802 
1803     /**
1804      * If the character is uppercase - converts the character to lowercase,
1805      * otherwise returns the character as it is. Only for ASCII characters.
1806      *
1807      * @return lowercase ASCII character equivalent
1808      */
1809     public static char toLowerCase(char c) {
1810         return isUpperCase(c) ? (char) (c + 32) : c;
1811     }
1812 
1813     private static byte toUpperCase(byte b) {
1814         return AsciiStringUtil.toUpperCase(b);
1815     }
1816 
1817     public static boolean isUpperCase(byte value) {
1818         return AsciiStringUtil.isUpperCase(value);
1819     }
1820 
1821     public static boolean isUpperCase(char value) {
1822         return value >= 'A' && value <= 'Z';
1823     }
1824 
1825     public static byte c2b(char c) {
1826         return (byte) ((c > MAX_CHAR_VALUE) ? '?' : c);
1827     }
1828 
1829     private static byte c2b0(char c) {
1830         return (byte) c;
1831     }
1832 
1833     public static char b2c(byte b) {
1834         return (char) (b & 0xFF);
1835     }
1836 }