Hide internal details of VM string implementation.

runtime/lib/string_base.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
- * [StringBase] contains common methods used by concrete String implementations,
- * e.g., OneByteString.
+ * [_StringBase] contains common methods used by concrete String implementations,
+ * e.g., _OneByteString.
  */
-class StringBase {
+class _StringBase {
 
-  factory StringBase._uninstantiable() {
+  factory _StringBase._uninstantiable() {
     throw const UnsupportedOperationException(
-        "StringBase can't be instaniated");
+        "_StringBase can't be instaniated");
   }
 
   int hashCode() native "String_hashCode";
 
   /**
    *  Create the most efficient string representation for specified
    *  [codePoints].
    */
   static String createFromCharCodes(List<int> charCodes) {
     _ObjectArray objectArray;
@@ skipping 52 matching lines @@
       }
       if (thisCodePoint > otherCodePoint) {
         return 1;
       }
     }
     if (thisLength < otherLength) return -1;
     if (thisLength > otherLength) return 1;
     return 0;
   }
 
-  bool substringMatches(int start, String other) {
+  bool _substringMatches(int start, String other) {
     if (other.isEmpty()) return true;
     if ((start < 0) || (start >= this.length)) {
       return false;
     }
     final int len = other.length;
     if ((start + len) > this.length) {
       return false;
     }
     for (int i = 0; i < len; i++) {
       if (this.charCodeAt(i + start) != other.charCodeAt(i)) {
         return false;
       }
     }
     return true;
   }
 
   bool endsWith(String other) {
-    return this.substringMatches(this.length - other.length, other);
+    return _substringMatches(this.length - other.length, other);
   }
 
   bool startsWith(String other) {
-    return this.substringMatches(0, other);
+    return _substringMatches(0, other);
   }
 
   int indexOf(String other, [int start = 0]) {
     if (other.isEmpty()) {
       return start < this.length ? start : this.length;
     }
     if ((start < 0) || (start >= this.length)) {
       return -1;
     }
     int len = this.length - other.length + 1;
     for (int index = start; index < len; index++) {
-      if (this.substringMatches(index, other)) {
+      if (_substringMatches(index, other)) {
         return index;
       }
     }
     return -1;
   }
 
   int lastIndexOf(String other, [int start = null]) {
     if (start == null) start = length - 1;
     if (other.isEmpty()) {
       return min(this.length, start);
     }
     if (start >= this.length) {
       start = this.length - 1;
     }
     for (int index = start; index >= 0; index--) {
-      if (this.substringMatches(index, other)) {
+      if (_substringMatches(index, other)) {
         return index;
       }
     }
     return -1;
   }
 
   String substring(int startIndex, [int endIndex]) {
     if (endIndex === null) endIndex = this.length;
 
     if ((startIndex < 0) || (startIndex > this.length)) {
@@ skipping 200 matching lines @@
       }
     }
     return _concatAll(stringsArray);
   }
 
   static String _concatAll(_ObjectArray<String> strings)
       native "Strings_concatAll";
 }
 
 
-class OneByteString extends StringBase implements String {
-  factory OneByteString._uninstantiable() {
+class _OneByteString extends _StringBase implements String {
+  factory _OneByteString._uninstantiable() {
     throw const UnsupportedOperationException(
-        "OneByteString can only be allocated by the VM");
+        "_OneByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint === 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 
 }
 
 
-class TwoByteString extends StringBase implements String {
-  factory TwoByteString._uninstantiable() {
+class _TwoByteString extends _StringBase implements String {
+  factory _TwoByteString._uninstantiable() {
     throw const UnsupportedOperationException(
-        "TwoByteString can only be allocated by the VM");
+        "_TwoByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint === 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
-class FourByteString extends StringBase implements String {
-  factory FourByteString._uninstantiable() {
+class _FourByteString extends _StringBase implements String {
+  factory _FourByteString._uninstantiable() {
     throw const UnsupportedOperationException(
-        "FourByteString can only be allocated by the VM");
+        "_FourByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint === 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
-class ExternalOneByteString extends StringBase implements String {
-  factory ExternalOneByteString._uninstantiable() {
+class _ExternalOneByteString extends _StringBase implements String {
+  factory _ExternalOneByteString._uninstantiable() {
     throw const UnsupportedOperationException(
-        "ExternalOneByteString can only be allocated by the VM");
+        "_ExternalOneByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint === 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
-class ExternalTwoByteString extends StringBase implements String {
+class _ExternalTwoByteString extends _StringBase implements String {
   factory ExternalTwoByteString._uninstantiable() {
     throw const UnsupportedOperationException(
-        "ExternalTwoByteString can only be allocated by the VM");
+        "_ExternalTwoByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint === 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
-class ExternalFourByteString extends StringBase implements String {
-  factory ExternalFourByteString._uninstantiable() {
+class _ExternalFourByteString extends _StringBase implements String {
+  factory _ExternalFourByteString._uninstantiable() {
     throw const UnsupportedOperationException(
         "ExternalFourByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
       (codePoint === 32) || // Space.
@@ skipping 24 matching lines @@
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int _start;
   final String str;
   final String pattern;
 }