Add String.repeat, String.padLeft, String.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 "";
+    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 newSize, String padding, { int size }) {
+    if (newSize < 0) throw new RangeError.value(newSize);
+    if (size == null) {
+      size = this.length;
+    } else if (size < 0) {
+      throw new RangeError.value(size);
+    }
+    int delta = newSize - size;
+    if (delta <= 0) return this;
+    StringBuffer buffer = new StringBuffer();
+    for (int i = 0; i < delta; i++) {

[floitsch, 2014/02/19 10:20:36]

In theory one could do the same trick as for efficient exponentiation: double
the padding at each iteration and only look at the bits.

Not sure it warrants a TODO.

[Lasse Reichstein Nielsen, 2014/02/19 11:43:16]

It is cute, though :)

+      buffer.write(padding);
+    }
+    buffer.write(this);
+    return buffer.toString();
+  }
+
+  String padRight(int newSize, String padding, { int size }) {
+    if (newSize < 0) throw new RangeError.value(newSize);
+    if (size == null) {
+      size = this.length;
+    } else if (size < 0) {
+      throw new RangeError.value(size);
+    }
+    int delta = newSize - size;
+    if (delta <= 0) return 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);
       }
       return indexOf(pattern, startIndex) >= 0;
     }
     return pattern.allMatches(this.substring(startIndex)).isNotEmpty;
   }
 
@@ skipping 310 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 "";
+    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));
+    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 j = 0; j < length; j++) {
+        result._setAt(index++, this.codeUnitAt(j));
+      }
+    }
+    return result;
+  }
+
+  String padLeft(int newSize, String padding, { int size }) {
+    int padCid = padding._cid;
+    if (padCid != _OneByteString._classId &&
+        padCid != _ExternalOneByteString._classId) {
+      return super.padLeft(newSize, padding, size: size);
+    }
+    int length = this.length;
+    if (size == null) {
+      size = length;
+    } else if (size < 0) {
+      throw new RangeError.value(size);
+    }
+    int delta = newSize - size;
+    if (delta <= 0) return this;
+    int padLength = padding.length;
+    _OneByteString result =
+        _OneByteString._allocate(length + delta * padLength);
+    int index = 0;
+    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 newSize, String padding, { int size }) {
+    int padCid = padding._cid;
+    if (padCid != _OneByteString._classId &&
+        padCid != _ExternalOneByteString._classId) {
+      return super.padRight(newSize, padding, size: size);
+    }
+    int length = this.length;
+    if (size == null) {
+      size = length;
+    } else if (size < 0) {
+      throw new RangeError.value(size);
+    }
+    int delta = newSize - size;
+    if (delta <= 0) return this;
+    int padLength = padding.length;
+    _OneByteString result =
+        _OneByteString._allocate(length + delta * padLength);
+    int index = 0;
+    for (int i = 0; i < length; i++) {
+      result._setAt(index++, this.codeUnitAt(i));
+    }
+    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)
       native "OneByteString_allocateFromOneByteList";
 
   // This is internal helper method. Code point value must be a valid
   // Latin1 value (0..0xFF), index must be valid.
@@ skipping 90 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);
 }