Create generic check methods for RangeError causing checks.

sdk/lib/core/errors.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;
 
 /**
  * Error objects thrown in the case of a program failure.
  *
  * An `Error` object represents a program failure that the programmer
@@ skipping 200 matching lines @@
    * description.
    */
   RangeError.value(num value, [String name, String message])
       : start = null, end = null,
         super.value(value, name,
                     (message != null) ? message : "Value not in range");
 
   /**
    * Create a new [RangeError] with for an invalid value being outside a range.
    *
-   * The allowed range is from [start] to [end], inclusive.
-   * If `start` or `end` are `null`, the range is infinite in that direction.
+   * The allowed range is from [minValue] to [maxValue], inclusive.
+   * If `minValue` or `maxValue` are `null`, the range is infinite in
+   * that direction.
    *
    * For a range from 0 to the length of something, end exclusive, use
    * [RangeError.index].
    *
    * An optional [name] can specify the argument name that has the
    * invalid value, and the [message] can override the default error
    * description.
    */
-  RangeError.range(num invalidValue, this.start, this.end,
+  RangeError.range(num invalidValue, int minValue, int maxValue,
                    [String name, String message])
-      : super.value(invalidValue, name,
+      : start = minValue,
+        end = maxValue,
+        super.value(invalidValue, name,
                     (message != null) ? message : "Invalid value");
 
   /**
    * Creates a new [RangeError] stating that [index] is not a valid index
    * into [indexable].
    *
    * An optional [name] can specify the argument name that has the
    * invalid value, and the [message] can override the default error
    * description.
    *
    * The [length] is the length of [indexable] at the time of the error.
    * If `length` is omitted, it defaults to `indexable.length`.
    */
   factory RangeError.index(int index, indexable,
                            [String name,
                             String message,
                             int length]) = IndexError;
 
+  /**
+   * Check that a [value] lies in a specific interval.
+   *
+   * Throws if [value] is not in the interval.
+   * The interval is from [minValue] to [maxValue], both inclusive.
+   */
+  static void checkValueInInterval(int value, int minValue, int maxValue,
+                                   [String name, String message]) {
+    if (value < minValue || value > maxValue) {
+      throw new RangeError.range(value, minValue, maxValue, name, message);
+    }
+  }
+
+  /**
+   * Check that a value is a valid index into an indexable object.
+   *
+   * Throws if [index] is not a valid index into [indexable].
+   *
+   * An indexable object is one that has a `length` and a and index-operator
+   * `[]` that accepts an index if `0 <= index < length`.
+   *
+   * If [length] is provided, it is used as the length of the indexable object,
+   * otherwise the length is found as `idexable.length`.
+   */
+  static void checkValidIndex(int index, var indexable,
+                              [String name, int length, String message]) {
+    if (length == null) length = indexable.length;
+    if (index < 0 || index >= length) {
+      if (name == null) name = "index";
+      throw new RangeError.index(index, indexable, name, message, length);
+    }
+  }
+
+  /**
+   * Check that a range represents a slice of an indexable object.
+   *
+   * Throws if the range is not valid for an indexable object with
+   * the given [length].
+   * A range is valid for an indexable object with a given [length]
+   *
+   * if `0 <= [start] <= [end] <= [length]`.
+   * An `end` of `null` is considered equivalent to `length`.
+   *
+   * The [startName] and [endName] defaults to `"start"` and `"end"`,
+   * respectively.
+   */
+  static void checkValidRange(int start, int end, int length,
+                              [String startName, String endName,
+                               String message]) {
+    if (start < 0 || start > length) {
+      if (startName == null) startName = "start";
+      throw new RangeError.range(start, 0, length, startName, message);
+    }
+    if (end != null && (end < start || end > length)) {
+      if (endName == null) endName = "end";
+      throw new RangeError.range(end, start, length, endName, message);
+    }
+  }
+
+  /**
+   * Check that an integer value isn't negative.
+   *
+   * Throws if the value is negative.
+   */
+  static void checkNotNegative(int value, [String name, String message]) {
+    if (value < 0) throw new RangeError.range(value, 0, null, name, message);
+  }
+
   String toString() {
     if (!_hasValue) return "RangeError: $message";
     String value = Error.safeToString(invalidValue);
     String explanation = "";
     if (start == null) {
       if (end != null) {
         explanation = ": Not less than or equal to $end";
       }
       // If both are null, we don't add a description of the limits.
     } else if (end == null) {
@@ skipping 215 matching lines @@
  * the first time it is read. If evaluating the initializer expression causes
  * another read of the variable, this error is thrown.
  */
 class CyclicInitializationError extends Error {
   final String variableName;
   CyclicInitializationError([this.variableName]);
   String toString() => variableName == null
       ? "Reading static variable during its initialization"
       : "Reading static variable '$variableName' during its initialization";
 }