Create generic check methods for RangeError causing checks.

sdk/lib/core/string.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.
 
 part of dart.core;
 
 /**
  * A sequence of characters.
  *
  * A string can be either single or multiline. Single line strings are
@@ skipping 622 matching lines @@
       : this.string = string, _position = 0, _nextPosition = 0;
 
   /**
    * Create an iterator positioned before the [index]th code unit of the string.
    *
    * When created, there is no [current] value.
    * A [moveNext] will use the rune starting at [index] the current value,
    * and a [movePrevious] will use the rune ending just before [index] as the
    * the current value.
    *
-   * It is an error if the [index] position is in the middle of a surrogate
-   * pair.
+   * The [index] position must not be in the middle of a surrogate pair.
    */
   RuneIterator.at(String string, int index)
       : string = string, _position = index, _nextPosition = index {
-    if (index < 0 || index > string.length) {
-      throw new RangeError.range(index, 0, string.length);
-    }
+    RangeError.checkValueInInterval(index, 0, string.length);
     _checkSplitSurrogate(index);
   }
 
   /** Throw an error if the index is in the middle of a surrogate pair. */
   void _checkSplitSurrogate(int index) {
     if (index > 0 && index < string.length &&
         _isLeadSurrogate(string.codeUnitAt(index - 1)) &&
         _isTrailSurrogate(string.codeUnitAt(index))) {
       throw new ArgumentError('Index inside surrogate pair: $index');
     }
   }
 
   /**
    * Returns the starting position of the current rune in the string.
    *
    * Returns null if the [current] rune is null.
    */
   int get rawIndex => (_position != _nextPosition) ? _position : null;
 
   /**
    * Resets the iterator to the rune at the specified index of the string.
    *
    * Setting a negative [rawIndex], or one greater than or equal to
    * [:string.length:],
    * is an error. So is setting it in the middle of a surrogate pair.
    *
    * Setting the position to the end of then string will set [current] to null.
    */
   void set rawIndex(int rawIndex) {
-    if (rawIndex >= string.length) {
-      throw new RangeError.index(rawIndex, string);
-    }
+    RangeError.checkValidIndex(rawIndex, string, "rawIndex");
     reset(rawIndex);
     moveNext();
   }
 
   /**
    * Resets the iterator to the given index into the string.
    *
    * After this the [current] value is unset.
    * You must call [moveNext] make the rune at the position current,
    * or [movePrevious] for the last rune before the position.
    *
    * Setting a negative [rawIndex], or one greater than [:string.length:],
    * is an error. So is setting it in the middle of a surrogate pair.
    */
   void reset([int rawIndex = 0]) {
-    if (rawIndex < 0 || rawIndex > string.length) {
-      throw new RangeError.range(rawIndex, 0, string.length);
-    }
+    RangeError.checkValueInInterval(rawIndex, 0, string.length, "rawIndex");
     _checkSplitSurrogate(rawIndex);
     _position = _nextPosition = rawIndex;
     _currentCodePoint = null;
   }
 
   /** The rune (integer Unicode code point) starting at the current position in
    *  the string.
    */
   int get current => _currentCodePoint;
 
@@ skipping 53 matching lines @@
         _position = position - 1;
         _currentCodePoint = _combineSurrogatePair(prevCodeUnit, codeUnit);
         return true;
       }
     }
     _position = position;
     _currentCodePoint = codeUnit;
     return true;
   }
 }