#if COPYRIGHT

//------------------------------------------------------------------------------

// <copyright file="Error.js" company="Microsoft">

// Copyright (c) Microsoft Corporation. All rights reserved.

// </copyright>

//------------------------------------------------------------------------------

#endif

Error.__typeName = 'Error';

Error.__class = true;

Error.create = function(message, errorInfo) {

/// <summary>Use this method to create a new error.</summary>

/// <param name="message" type="String" optional="true" mayBeNull="true">The error message.</param>

/// <param name="errorInfo" optional="true" mayBeNull="true">

/// A plain JavaScript object that contains extended information about the error.

/// The object should have a 'name' field that contains a string that identifies the error

/// and any additional fields that are necessary to fully describe the error.

/// </param>

/// <returns type="Error">An Error object.</returns>

// If message string can be converted to a number, IE sets e.message to the number, not the string.

// Workaround this issue by explicitly setting e.message to the string.

var err = new Error(message);

err.message = message;

if (errorInfo) {

for (var v in errorInfo) {

err[v] = errorInfo[v];

}

}

err.popStackFrame();

return err;

}

// The ArgumentException ctor in .NET has the message *before* paramName. This

// is inconsistent with all the other Argument*Exception ctors in .NET.

// We feel the paramName is more important than the message, and we want all our

// argument errors to be consistent, so our Error.argument() takes the paramName

// before the message. This is inconsistent with .NET, but overall we feel

// it is the better design.

Error.argument = function(paramName, message) {

/// <summary>

/// Creates an ArgumentException with a specified error message

/// and the name of the parameter that caused this exception.

/// </summary>

/// <param name="paramName" type="String" optional="true" mayBeNull="true">

/// The name of the parameter that caused the exception.

/// </param>

/// <param name="message" type="String" optional="true" mayBeNull="true">

/// A message that describes the error.

/// </param>

/// <returns>An Error instance that represents an ArgumentException.</returns>

var displayMessage = "Sys.ArgumentException: " + (message ? message : Sys.Res.argument);

if (paramName) {

displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

}

var err = Error.create(displayMessage, { name: "Sys.ArgumentException", paramName: paramName });

err.popStackFrame();

return err;

}

Error.argumentNull = function(paramName, message) {

/// <summary>

/// Creates an ArgumentNullException with a specified error message

/// and the name of the parameter that caused this exception.

/// </summary>

/// <param name="paramName" type="String" optional="true" mayBeNull="true">

/// The name of the parameter that caused the exception.

/// </param>

/// <param name="message" type="String" optional="true" mayBeNull="true">

/// A message that describes the error.

/// </param>

/// <returns>An Error instance that represents an ArgumentNullException.</returns>

var displayMessage = "Sys.ArgumentNullException: " + (message ? message : Sys.Res.argumentNull);

if (paramName) {

displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

}

var err = Error.create(displayMessage, { name: "Sys.ArgumentNullException", paramName: paramName });

err.popStackFrame();

return err;

}

Error.argumentOutOfRange = function(paramName, actualValue, message) {

/// <summary>

/// Creates an ArgumentOutOfRangeException with a specified error message

/// and the name and actual value of the parameter that caused this exception.

/// </summary>

/// <param name="paramName" type="String" optional="true" mayBeNull="true">

/// The name of the parameter that caused the exception.

/// </param>

/// <param name="actualValue" optional="true" mayBeNull="true">

/// The actual value of the parameter.

/// </param>

/// <param name="message" type="String" optional="true" mayBeNull="true">

/// A message that describes the error.

/// </param>

/// <returns>An Error instance that represents an ArgumentOutOfRangeException.</returns>

var displayMessage = "Sys.ArgumentOutOfRangeException: " + (message ? message : Sys.Res.argumentOutOfRange);

if (paramName) {

displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

}

// .NET implementation of ArgumentOutOfRangeException does not display actualValue if it is null.

// For parity with .NET, we do not display if actualValue is null or undefined. This is OK,

// since more specific exceptions exist for null and undefined.

if (typeof(actualValue) !== "undefined" && actualValue !== null) {

displayMessage += "\n" + String.format(Sys.Res.actualValue, actualValue);

}

var err = Error.create(displayMessage, {

name: "Sys.ArgumentOutOfRangeException",

paramName: paramName,

actualValue: actualValue

});

err.popStackFrame();

return err;

}

Error.argumentType = function(paramName, actualType, expectedType, message) {

/// <summary>

/// Creates an ArgumentTypeException with a specified error message

/// and the name, actual type, and expected type of the parameter that

/// caused this exception.

/// </summary>

/// <param name="paramName" type="String" optional="true" mayBeNull="true">

/// The name of the parameter that caused the exception.

/// </param>

/// <param name="actualType" type="Type" optional="true" mayBeNull="true">

/// The actual type of the parameter value.

/// </param>

/// <param name="expectedType" type="Type" optional="true" mayBeNull="true">

/// The expected type of the parameter value.

/// </param>

/// <param name="message" type="String" optional="true" mayBeNull="true">

/// A message that describes the error.

/// </param>

/// <returns>An Error instance that represents an ArgumentTypeException.</returns>

var displayMessage = "Sys.ArgumentTypeException: ";

if (message) {

displayMessage += message;

}

else if (actualType && expectedType) {

displayMessage +=

String.format(Sys.Res.argumentTypeWithTypes, actualType.getName(), expectedType.getName());

}

else {

displayMessage += Sys.Res.argumentType;

}

if (paramName) {

displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

}

var err = Error.create(displayMessage, {

name: "Sys.ArgumentTypeException",

paramName: paramName,

actualType: actualType,

expectedType: expectedType

});

err.popStackFrame();

return err;

}

Error.argumentUndefined = function(paramName, message) {

/// <summary>

/// Creates an ArgumentUndefinedException with a specified error message

/// and the name of the parameter that caused this exception.

/// </summary>

/// <param name="paramName" type="String" optional="true" mayBeNull="true">

/// The name of the parameter that caused the exception.

/// </param>

/// <param name="message" type="String" optional="true" mayBeNull="true">

/// A message that describes the error.

/// </param>

/// <returns>An Error instance that represents an ArgumentUndefinedException.</returns>

var displayMessage = "Sys.ArgumentUndefinedException: " + (message ? message : Sys.Res.argumentUndefined);

if (paramName) {

displayMessage += "\n" + String.format(Sys.Res.paramName, paramName);

}

var err = Error.create(displayMessage, { name: "Sys.ArgumentUndefinedException", paramName: paramName });

err.popStackFrame();

return err;

}

Error.format = function(message) {

/// <summary>

/// Creates a format error.

/// </summary>

/// <param name="message" type="String" optional="true" mayBeNull="true">The error message.</param>

/// <returns>An Error object that represents a FormatException.</returns>

var displayMessage = "Sys.FormatException: " + (message ? message : Sys.Res.format);

var err = Error.create(displayMessage, {name: 'Sys.FormatException'});

err.popStackFrame();

return err;

}

Error.invalidOperation = function(message) {

/// <summary>

/// Creates an invalid operation error.

/// </summary>

/// <param name="message" type="String" optional="true" mayBeNull="true">The error message.</param>

/// <returns>An Error instance that represents an InvalidOperationException.</returns>

var displayMessage = "Sys.InvalidOperationException: " + (message ? message : Sys.Res.invalidOperation);

var err = Error.create(displayMessage, {name: 'Sys.InvalidOperationException'});

err.popStackFrame();

return err;

}

Error.notImplemented = function(message) {

/// <summary>

/// Creates a not implemented error.

/// </summary>

/// <param name="message" type="String" optional="true" mayBeNull="true">The error message.</param>

/// <returns>An Error instance that represents a NotImplementedException.</returns>

var displayMessage = "Sys.NotImplementedException: " + (message ? message : Sys.Res.notImplemented);

var err = Error.create(displayMessage, {name: 'Sys.NotImplementedException'});

err.popStackFrame();

return err;

}

Error.parameterCount = function(message) {

/// <summary>

/// Creates a ParameterCountException with a specified error message.

/// </summary>

/// <param name="message" type="String" optional="true" mayBeNull="true">

/// A message that describes the error.

/// </param>

/// <returns>An Error instance that represents a ParameterCountException.</returns>

var displayMessage = "Sys.ParameterCountException: " + (message ? message : Sys.Res.parameterCount);

var err = Error.create(displayMessage, {name: 'Sys.ParameterCountException'});

err.popStackFrame();

return err;

}

Error.prototype.popStackFrame = function() {

/// <summary>

/// Updates the fileName and lineNumber fields based on the next frame in the

/// stack trace. Call this method whenever an instance of Error is returned

/// from a function. This makes the fileName and lineNumber reported in the

/// FireFox console point to the location where the exception was thrown, not

/// the location where the instance of Error was created.

/// </summary>

/// <example>

/// function checkParam(param, expectedType) {

/// if (!expectedType.isInstanceOfType(param)) {

/// var e = new Error("invalid type");

/// e.popStackFrame();

/// return e;

/// }

/// }

/// </example>

// Example stack frame

// ===================

// Error("test error")@:0

// createError()@http://localhost/app/Error.js:2

// throwError()@http://localhost/app/Error.js:6

// callThrowError()@http://localhost/app/Error.js:10

// @http://localhost/app/Error:js:14

if (typeof(this.stack) === "undefined" || this.stack === null ||

typeof(this.fileName) === "undefined" || this.fileName === null ||

typeof(this.lineNumber) === "undefined" || this.lineNumber === null) {

return;

}

var stackFrames = this.stack.split("\n");

// Find current stack frame. It may not be the first stack frame, since the very

// first frame when the Error is constructed does not correspond to any actual file

// or line number. See example stack frame above.

var currentFrame = stackFrames[0];

var pattern = this.fileName + ":" + this.lineNumber;

while(typeof(currentFrame) !== "undefined" &&

currentFrame !== null &&

currentFrame.indexOf(pattern) === -1) {

stackFrames.shift();

currentFrame = stackFrames[0];

}

var nextFrame = stackFrames[1];

// Special-case last stack frame, to stop shifting frames off the stack.

if (typeof(nextFrame) === "undefined" || nextFrame === null) {

return;

}

// Update fields to correspond with next stack frame

var nextFrameParts = nextFrame.match(/@(.*):(\d+)$/);

if (typeof(nextFrameParts) === "undefined" || nextFrameParts === null) {

return;

}

this.fileName = nextFrameParts[1];

// This should always succeed, since the regex matches "\d+"

this.lineNumber = parseInt(nextFrameParts[2]);

stackFrames.shift();

this.stack = stackFrames.join("\n");

}