src/java.base/share/classes/java/lang/StringUTF16.java

rev 51519 : 8200434: String::align, String::indent
Reviewed-by: smarks

*** 857,867 ****
          return ((st > 0) || (len < length )) ?
              new String(Arrays.copyOfRange(value, st << 1, len << 1), UTF16) :
              null;
      }
  
- 
      public static int indexOfNonWhitespace(byte[] value) {
          int length = value.length >> 1;
          int left = 0;
          while (left < length) {
              int codepoint = codePointAt(value, left, length);
--- 857,866 ----
*** 872,882 ****
          }
          return left;
      }
  
      public static int lastIndexOfNonWhitespace(byte[] value) {
!         int length = value.length >> 1;
          int right = length;
          while (0 < right) {
              int codepoint = codePointBefore(value, right);
              if (codepoint != ' ' && codepoint != '\t' && !Character.isWhitespace(codepoint)) {
                  break;
--- 871,881 ----
          }
          return left;
      }
  
      public static int lastIndexOfNonWhitespace(byte[] value) {
!         int length = value.length >>> 1;
          int right = length;
          while (0 < right) {
              int codepoint = codePointBefore(value, right);
              if (codepoint != ' ' && codepoint != '\t' && !Character.isWhitespace(codepoint)) {
                  break;
*** 885,914 ****
          }
          return right;
      }
  
      public static String strip(byte[] value) {
!         int length = value.length >> 1;
          int left = indexOfNonWhitespace(value);
          if (left == length) {
              return "";
          }
          int right = lastIndexOfNonWhitespace(value);
!         return ((left > 0) || (right < length)) ? newString(value, left, right - left) : null;
      }
  
      public static String stripLeading(byte[] value) {
!         int length = value.length >> 1;
          int left = indexOfNonWhitespace(value);
          if (left == length) {
              return "";
          }
          return (left != 0) ? newString(value, left, length - left) : null;
      }
  
      public static String stripTrailing(byte[] value) {
!         int length = value.length >> 1;
          int right = lastIndexOfNonWhitespace(value);
          if (right == 0) {
              return "";
          }
          return (right != length) ? newString(value, 0, right) : null;
--- 884,914 ----
          }
          return right;
      }
  
      public static String strip(byte[] value) {
!         int length = value.length >>> 1;
          int left = indexOfNonWhitespace(value);
          if (left == length) {
              return "";
          }
          int right = lastIndexOfNonWhitespace(value);
!         boolean ifChanged = (left > 0) || (right < length);
!         return ifChanged ? newString(value, left, right - left) : null;
      }
  
      public static String stripLeading(byte[] value) {
!         int length = value.length >>> 1;
          int left = indexOfNonWhitespace(value);
          if (left == length) {
              return "";
          }
          return (left != 0) ? newString(value, left, length - left) : null;
      }
  
      public static String stripTrailing(byte[] value) {
!         int length = value.length >>> 1;
          int right = lastIndexOfNonWhitespace(value);
          if (right == 0) {
              return "";
          }
          return (right != length) ? newString(value, 0, right) : null;
*** 917,931 ****
      private final static class LinesSpliterator implements Spliterator<String> {
          private byte[] value;
          private int index;        // current index, modified on advance/split
          private final int fence;  // one past last index
  
!         LinesSpliterator(byte[] value) {
!             this(value, 0, value.length >>> 1);
!         }
! 
!         LinesSpliterator(byte[] value, int start, int length) {
              this.value = value;
              this.index = start;
              this.fence = start + length;
          }
  
--- 917,927 ----
      private final static class LinesSpliterator implements Spliterator<String> {
          private byte[] value;
          private int index;        // current index, modified on advance/split
          private final int fence;  // one past last index
  
!         private LinesSpliterator(byte[] value, int start, int length) {
              this.value = value;
              this.index = start;
              this.fence = start + length;
          }
  
*** 1000,1013 ****
  
          @Override
          public int characteristics() {
              return Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL;
          }
      }
  
!     static Stream<String> lines(byte[] value) {
!         return StreamSupport.stream(new LinesSpliterator(value), false);
      }
  
      private static void putChars(byte[] val, int index, char[] str, int off, int end) {
          while (off < end) {
              putChar(val, index++, str[off++]);
--- 996,1079 ----
  
          @Override
          public int characteristics() {
              return Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL;
          }
+ 
+         static LinesSpliterator spliterator(byte[] value) {
+             return new LinesSpliterator(value, 0, value.length >>> 1);
+         }
+ 
+         static LinesSpliterator spliterator(byte[] value, int leading, int trailing) {
+             int length = value.length >>> 1;
+             int left = 0;
+             int index;
+             for (int l = 0; l < leading; l++) {
+                 index = skipBlankForward(value, left, length);
+                 if (index == left) {
+                     break;
+                 }
+                 left = index;
+             }
+             int right = length;
+             for (int t = 0; t < trailing; t++) {
+                 index = skipBlankBackward(value, left, right);
+                 if (index == right) {
+                     break;
+                 }
+                 right = index;
+             }
+             return new LinesSpliterator(value, left, right - left);
          }
  
!         private static int skipBlankForward(byte[] value, int start, int length) {
!             int index = start;
!             while (index < length) {
!                 char ch = getChar(value, index++);
!                 if (ch == '\n') {
!                     return index;
!                 }
!                 if (ch == '\r') {
!                     if (index < length && getChar(value, index) == '\n') {
!                         return index + 1;
!                     }
!                     return index;
!                 }
!                 if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
!                     return start;
!                 }
!             }
!             return length;
!         }
! 
!         private static int skipBlankBackward(byte[] value, int start, int fence) {
!             int index = fence;
!             if (start < index && getChar(value, index - 1) == '\n') {
!                 index--;
!             }
!             if (start < index && getChar(value, index - 1) == '\r') {
!                 index--;
!             }
!             while (start < index) {
!                 char ch = getChar(value, --index);
!                 if (ch == '\r' || ch == '\n') {
!                     return index + 1;
!                 }
!                 if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
!                     return fence;
!                 }
!             }
!             return start;
!         }
!     }
! 
!     static Stream<String> lines(byte[] value, int leading, int trailing) {
!         if (leading == 0 && trailing == 0) {
!             return StreamSupport.stream(LinesSpliterator.spliterator(value), false);
!         } else {
!             return StreamSupport.stream(LinesSpliterator.spliterator(value, leading, trailing), false);
!         }
      }
  
      private static void putChars(byte[] val, int index, char[] str, int off, int end) {
          while (off < end) {
              putChar(val, index++, str[off++]);