Allow multi-codeunit padding in String.padLeft/padRight.

runtime/lib/string_patch.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.
 
 patch class String {
   /* patch */ factory String.fromCharCodes(Iterable<int> charCodes) {
     return _StringBase.createFromCharCodes(charCodes);
   }
 
   /* patch */ const factory String.fromEnvironment(String name,
@@ skipping 284 matching lines @@
     }
     if ((first == 0) && (last == (len - 1))) {
       // Returns this string if it does not have leading or trailing
       // whitespaces.
       return this;
     } else {
       return _substringUnchecked(first, last + 1);
     }
   }
 
-  String repeat(int times, [String separator = ""]) {
-    if (times < 0) throw new RangeError.value(times);
-    if (times == 0) return "";
+  String operator*(int times) {
+    if (times <= 0) return "";
     if (times == 1) return this;
     StringBuffer buffer = new StringBuffer(this);
-    if (separator.isEmpty) {
-      for (int i = 1; i < times; i++) {
-        buffer.write(this);
-      }
-      return buffer.toString();
-    }
     for (int i = 1; i < times; i++) {
-      buffer.write(separator);
       buffer.write(this);
     }
     return buffer.toString();
   }
 
-  String padLeft(int newLength, String padding) {
-    if (padding.length != 1) throw new ArgumentError(padding);
-    int delta = newLength - this.length;
+  String padLeft(int width, [String padding = ' ']) {
+    int delta = width - this.length;
     if (delta <= 0) return this;
     StringBuffer buffer = new StringBuffer();
     for (int i = 0; i < delta; i++) {
       buffer.write(padding);
     }
     buffer.write(this);
     return buffer.toString();
   }
 
-  String padRight(int newLength, String padding, { int size }) {
-    if (padding.length != 1) throw new ArgumentError(padding);
-    int delta = newLength - this.length;
+  String padRight(int width, [String padding = ' ']) {
+    int delta = width - this.length;
     if (delta <= 0) return this;
-    StringBuffer buffer = new StringBuffer();
-    buffer.write(this);
+    StringBuffer buffer = new StringBuffer(this);
     for (int i = 0; i < delta; i++) {
       buffer.write(padding);
     }
     return buffer.toString();
   }
 
   bool contains(Pattern pattern, [int startIndex = 0]) {
     if (pattern is String) {
       if (startIndex < 0 || startIndex > this.length) {
         throw new RangeError.range(startIndex, 0, this.length);
@@ skipping 316 matching lines @@
           if (this.codeUnitAt(i) == patternCu0) {
             return true;
           }
         }
         return false;
       }
     }
     return super.contains(pattern, start);
   }
 
-  String repeat(int times, [String separator = ""]) {
-    if (times == 0) return "";
+  String operator*(int times) {

[Lasse Reichstein Nielsen, 2014/02/20 07:16:40]

These one-byte optimizations are missing from _ExternalOneByteString.
Would it make sense to have a _OneByteStringBase that can be inherited by all
one byte strings?

+    if (times <= 0) return "";
     if (times == 1) return this;
-    if (times < 0) throw new RangeError.value(times);
-    if (separator.isEmpty) {
-      int length = this.length;
-      if (this.isEmpty) return this;  // Don't clone empty string.
-      _OneByteString result = _OneByteString._allocate(length * times);
-      int index = 0;
-      for (int i = 0; i < times; i ++) {
-        for (int j = 0; j < length; j++) {
-          result._setAt(index++, this.codeUnitAt(j));
-        }
-      }
-      return result;
-    }
-    int sepCid = separator._cid;
-    if (sepCid != _OneByteString._classId &&
-        sepCid != _ExternalOneByteString._classId) {
-      return super.repeat(times, separator);
-    }
     int length = this.length;
-    int sepLength = separator.length;
-    _OneByteString result =
-        _OneByteString._allocate(length * times + sepLength * (times - 1));
+    if (this.isEmpty) return this;  // Don't clone empty string.
+    _OneByteString result = _OneByteString._allocate(length * times);
     int index = 0;
-    for (int j = 0; j < length; j++) {
-      result._setAt(index++, this.codeUnitAt(j));
-    }
-    for (int i = 1; i < times; i ++) {
-      for (int j = 0; j < sepLength; j++) {
-        result._setAt(index++, separator.codeUnitAt(j));
-      }
+    for (int i = 0; i < times; i ++) {
       for (int j = 0; j < length; j++) {
         result._setAt(index++, this.codeUnitAt(j));
       }
     }
     return result;
   }
 
-  String padLeft(int newLength, String padding) {
-    if (padding.length != 1) throw new ArgumentError(padding);
+  String padLeft(int width, [String padding = ' ']) {
     int padCid = padding._cid;
     if (padCid != _OneByteString._classId &&
         padCid != _ExternalOneByteString._classId) {
-      return super.padLeft(newLength, padding);
+      return super.padLeft(width, padding);
     }
     int length = this.length;
-    int delta = newLength - length;
+    int delta = width - length;
     if (delta <= 0) return this;
-    _OneByteString result = _OneByteString._allocate(newLength);
+    int padLength = padding.length;
+    int resultLength = padLength * delta + length;
+    _OneByteString result = _OneByteString._allocate(resultLength);
     int index = 0;
-    int padChar = padding.codeUnitAt(0);
-    for (int i = 0; i < delta; i++) {
-      result._setAt(index++, padChar);
+    if (padLength == 1) {
+      int padChar = padding.codeUnitAt(0);
+      for (int i = 0; i < delta; i++) {
+        result._setAt(index++, padChar);
+      }
+    } else {
+      for (int i = 0; i < delta; i++) {
+        for (int j = 0; j < padLength; j++) {
+          result._setAt(index++, padding.codeUnitAt(j));
+        }
+      }
     }
     for (int i = 0; i < length; i++) {
       result._setAt(index++, this.codeUnitAt(i));
     }
     return result;
   }
 
-  String padRight(int newLength, String padding, { int size }) {
-    if (padding.length != 1) throw new ArgumentError(padding);
+  String padRight(int width, [String padding = ' ']) {
     int padCid = padding._cid;
     if (padCid != _OneByteString._classId &&
         padCid != _ExternalOneByteString._classId) {
-      return super.padRight(newLength, padding);
+      return super.padRight(width, padding);
     }
     int length = this.length;
-    int delta = newLength - length;
+    int delta = width - length;
     if (delta <= 0) return this;
-    _OneByteString result = _OneByteString._allocate(newLength);
+    int padLength = padding.length;
+    int resultLength = length + padLength * delta;
+    _OneByteString result = _OneByteString._allocate(resultLength);
     int index = 0;
     for (int i = 0; i < length; i++) {
       result._setAt(index++, this.codeUnitAt(i));
     }
-    int padChar = padding.codeUnitAt(0);
-    for (int i = 0; i < delta; i++) {
-      result._setAt(index++, padChar);
+    if (padLength == 1) {
+      int padChar = padding.codeUnitAt(0);
+      for (int i = 0; i < delta; i++) {
+        result._setAt(index++, padChar);
+      }
+    } else {
+      for (int i = 0; i < delta; i++) {
+        for (int j = 0; j < padLength; j++) {
+          result._setAt(index++, padding.codeUnitAt(j));
+        }
+      }
     }
     return result;
   }
 
   // Allocates a string of given length, expecting its content to be
   // set using _setAt.
   static _OneByteString _allocate(int length) native "OneByteString_allocate";
 
 
   static _OneByteString _allocateFromOneByteList(List<int> list)
@@ skipping 94 matching lines @@
 class _CodeUnits extends Object with ListMixin<int>,
                                      UnmodifiableListMixin<int> {
   /** The string that this is the code units of. */
   String _string;
 
   _CodeUnits(this._string);
 
   int get length => _string.length;
   int operator[](int i) => _string.codeUnitAt(i);
 }