Source: Core/DeveloperError.js

  1. /*global define*/
  2. define([
  3.         './defined'
  4.     ], function(
  5.         defined) {
  6.     'use strict';
  8.     /**
  9.      * Constructs an exception object that is thrown due to a developer error, e.g., invalid argument,
  10.      * argument out of range, etc.  This exception should only be thrown during development;
  11.      * it usually indicates a bug in the calling code.  This exception should never be
  12.      * caught; instead the calling code should strive not to generate it.
  13.      * <br /><br />
  14.      * On the other hand, a {@link RuntimeError} indicates an exception that may
  15.      * be thrown at runtime, e.g., out of memory, that the calling code should be prepared
  16.      * to catch.
  17.      *
  18.      * @alias DeveloperError
  19.      * @constructor
  20.      * @extends Error
  21.      *
  22.      * @param {String} [message] The error message for this exception.
  23.      *
  24.      * @see RuntimeError
  25.      */
  26.     function DeveloperError(message) {
  27.         /**
  28.          * 'DeveloperError' indicating that this exception was thrown due to a developer error.
  29.          * @type {String}
  30.          * @readonly
  31.          */
  32.         this.name = 'DeveloperError';
  34.         /**
  35.          * The explanation for why this exception was thrown.
  36.          * @type {String}
  37.          * @readonly
  38.          */
  39.         this.message = message;
  41.         //Browsers such as IE don't have a stack property until you actually throw the error.
  42.         var stack;
  43.         try {
  44.             throw new Error();
  45.         } catch (e) {
  46.             stack = e.stack;
  47.         }
  49.         /**
  50.          * The stack trace of this exception, if available.
  51.          * @type {String}
  52.          * @readonly
  53.          */
  54.         this.stack = stack;
  55.     }
  57.     if (defined(Object.create)) {
  58.         DeveloperError.prototype = Object.create(Error.prototype);
  59.         DeveloperError.prototype.constructor = DeveloperError;
  60.     }
  62.     DeveloperError.prototype.toString = function() {
  63.         var str = this.name + ': ' + this.message;
  65.         if (defined(this.stack)) {
  66.             str += '\n' + this.stack.toString();
  67.         }
  69.         return str;
  70.     };
  72.     /**
  73.      * @private
  74.      */
  75.     DeveloperError.throwInstantiationError = function() {
  76.         throw new DeveloperError('This function defines an interface and should not be called directly.');
  77.     };
  79.     return DeveloperError;
  80. });